@mastra/duckdb 1.12.1 → 1.13.0-alpha.1

package/dist/{observability-BmLO_YTO.js → observability-Bk_y3hof.js}

@@ -1,4 +1,4 @@
-import { t as DuckDBConnection } from "./db-BWgrbB_u.js";
+import { n as DuckDBConnection, r as DuckDBQueryTimeoutError, t as spanQueryFeatures } from "./features-D3sUOsCL.js";
 import { ErrorCategory, ErrorDomain, MastraError } from "@mastra/core/error";
 import * as coreStorage from "@mastra/core/storage";
 import { BRANCH_SPAN_TYPES, METRIC_DISTINCT_COLUMNS, ObservabilityStorage, buildInputPreview, computeTraceStatus, createStorageErrorId, executeRetentionPrune, feedbackRecordSchema, listBranchesArgsSchema, listFeedbackArgsSchema, listLogsArgsSchema, listMetricsArgsSchema, listScoresArgsSchema, listTracesArgsSchema, resolveRetentionTargets, retentionCutoffMs, toTraceSpans } from "@mastra/core/storage";
@@ -2703,6 +2703,15 @@ const TRACE_STATUS_SQL = `CASE WHEN r.error IS NOT NULL THEN 'error' ELSE 'succe
 function durationMsSql(startedAt, endedAt) {
 	return `date_diff('millisecond', ${startedAt}, ${endedAt})`;
 }
+/**
+* Top-level string metadata value of the trace root (alias `r`). The SQL binds the JSON path
+* twice; use `traceMetadataPathValues` for the matching parameters.
+*/
+const TRACE_METADATA_VALUE_SQL = `NULLIF(trim(CASE WHEN json_type(r.metadata, ?) = 'VARCHAR' THEN json_extract_string(r.metadata, ?) END), '')`;
+function traceMetadataPathValues(key) {
+	const path = `$.${JSON.stringify(key)}`;
+	return [path, path];
+}
 const TRACE_FIELDS = {
 	traceId: {
 		sql: "r.traceId",
@@ -2969,13 +2978,11 @@ function compileScalarPredicate(predicate, registry, allowMetadata = false) {
 	let fieldValues = [];
 	if (isMetadataField(predicate.field)) {
 		if (!allowMetadata) throw new Error(`Unsupported trusted trace-query field: ${predicate.field}`);
-		const key = predicate.field.slice(9);
-		const path = `$.${JSON.stringify(key)}`;
 		field = {
-			sql: `NULLIF(trim(CASE WHEN json_type(r.metadata, ?) = 'VARCHAR' THEN json_extract_string(r.metadata, ?) END), '')`,
+			sql: TRACE_METADATA_VALUE_SQL,
 			parameterType: "scalar"
 		};
-		fieldValues = [path, path];
+		fieldValues = traceMetadataPathValues(predicate.field.slice(9));
 	} else field = fieldDefinition(registry, predicate.field);
 	if (predicate.type === "presence") return {
 		sql: `${field.sql} IS ${predicate.operator === "exists" ? "NOT " : ""}NULL`,
@@ -3152,15 +3159,66 @@ function collectThreadRelatedCollections(predicate, collections) {
 	else collectThreadRelatedCollections(predicate.arg, collections);
 	return collections;
 }
-function compileDuckDBTraceScope(relatedCollections, scope) {
+const ROOT_PUSHDOWN_FIELDS = /* @__PURE__ */ new Set([
+	"traceId",
+	"threadId",
+	"resourceId",
+	"runId",
+	"sessionId",
+	"userId",
+	"organizationId",
+	"endedAt",
+	"entityName",
+	"entityType",
+	"environment"
+]);
+function isRootPushdownPredicate(predicate) {
+	if (predicate.type === "relation") return false;
+	if (predicate.type === "boolean") return predicate.args.every(isRootPushdownPredicate);
+	if (predicate.type === "not") return isRootPushdownPredicate(predicate.arg);
+	return ROOT_PUSHDOWN_FIELDS.has(predicate.field);
+}
+/** Top-level AND conjuncts of `where` that only read root-row columns. */
+function rootPushdownPredicates(predicate) {
+	if (!predicate) return [];
+	return (predicate.type === "boolean" && predicate.operator === "and" ? predicate.args : [predicate]).filter(isRootPushdownPredicate);
+}
+/**
+* Builds the selection CTEs. `root_trace_ids` narrows the root scan to traces that could have a
+* qualifying current root before the window functions run: some root event carries the current
+* root's own conditions (ended, tenant, pushed `where` conjuncts) and some root event has a
+* timestamp in the window (the current root's `startedAt` is a root event's timestamp in its
+* trace). This only removes traces that cannot qualify; `root_events` / `current_roots` still see
+* every root event of the remaining traces, and the full `where` is applied in `candidates`.
+*/
+function compileDuckDBTraceScope(relatedCollections, scope, timeRange, rootPredicates = []) {
 	const tenantConditions = (alias) => scope ? [`${alias}.organizationId = ?`, ...scope.resourceId === void 0 ? [] : [`${alias}.resourceId = ?`]] : [];
 	const tenantValues = scope ? scope.resourceId === void 0 ? [scope.organizationId] : [scope.organizationId, scope.resourceId] : [];
 	const tenantWhere = (alias) => {
 		const conditions = tenantConditions(alias);
 		return conditions.length ? `\n      WHERE ${conditions.join(" AND ")}` : "";
 	};
-	const values = [...tenantValues];
+	const rowConditions = ["r.endedAt IS NOT NULL", ...tenantConditions("r")];
+	const values = [
+		timeRange.from,
+		timeRange.to,
+		...tenantValues
+	];
+	for (const predicate of rootPredicates) {
+		const compiled = compilePredicate(predicate);
+		rowConditions.push(`(${compiled.sql})`);
+		values.push(...compiled.values);
+	}
+	values.push(timeRange.from, timeRange.to, ...tenantValues);
 	const ctes = [
+		`root_trace_ids AS (
+      SELECT r.traceId
+      FROM span_events r
+      WHERE r.parentSpanId IS NULL
+      GROUP BY r.traceId
+      HAVING bool_or(r.timestamp >= CAST(? AS TIMESTAMP) AND r.timestamp < CAST(? AS TIMESTAMP))
+        AND bool_or(${rowConditions.join("\n          AND ")})
+    )`,
 		`root_events AS (
       SELECT
         *,
@@ -3170,6 +3228,7 @@ function compileDuckDBTraceScope(relatedCollections, scope) {
         END AS startedAt
       FROM span_events
       WHERE parentSpanId IS NULL
+        AND traceId IN (SELECT traceId FROM root_trace_ids)
     )`,
 		`current_roots AS (
       SELECT * EXCLUDE (rootRank)
@@ -3257,28 +3316,30 @@ function compileDuckDBTraceScope(relatedCollections, scope) {
 		values
 	};
 }
-function compileDuckDBTraceQuery(plan) {
-	const { ctes, values: scopeValues } = compileDuckDBTraceScope(collectRelatedCollections(plan.where), plan.scope);
-	const values = [
-		plan.timeRange.from,
-		plan.timeRange.to,
-		...scopeValues
-	];
-	const conditions = [
-		`r.endedAt IS NOT NULL`,
-		`r.startedAt >= CAST(? AS TIMESTAMP)`,
-		`r.startedAt < CAST(? AS TIMESTAMP)`
-	];
+/**
+* Builds the trace selection stages shared by trace queries and trace aggregates: root scope,
+* related-collection scopes, and a `candidates` CTE projecting `columns` from matching roots.
+*/
+function compileDuckDBTraceCandidates(plan, columns) {
+	const { ctes, values } = compileDuckDBTraceScope(collectRelatedCollections(plan.where), plan.scope, plan.timeRange, rootPushdownPredicates(plan.where));
+	let predicateSql = "TRUE";
 	if (plan.where) {
 		const predicate = compilePredicate(plan.where);
-		conditions.push(`(${predicate.sql})`);
+		predicateSql = `(${predicate.sql})`;
 		values.push(...predicate.values);
 	}
 	ctes.push(`candidates AS (
-    SELECT ${TRACE_SELECT}${plan.paginationMode === "delta" ? ", r.cursorId AS deltaWatermark" : ""}
+    SELECT ${columns}
     FROM root_scope r
-    WHERE ${conditions.slice(3).join("\n      AND ") || "TRUE"}
+    WHERE ${predicateSql}
   )`);
+	return {
+		ctes,
+		values
+	};
+}
+function compileDuckDBTraceQuery(plan) {
+	const { ctes, values } = compileDuckDBTraceCandidates(plan, `${TRACE_SELECT}${plan.paginationMode === "delta" ? ", r.cursorId AS deltaWatermark" : ""}`);
 	const candidates = `WITH ${ctes.join(",\n  ")}`;
 	if (plan.result === "groups") {
 		const pageCondition = plan.cursor ? `AND threadId > ?` : "";
@@ -3301,7 +3362,7 @@ LIMIT ?`,
 		values.push(watermark ?? "0", plan.limit + 1);
 		return {
 			sql: `${candidates},
-  delta_head AS (SELECT coalesce(max(cursorId), 0) AS streamHead FROM root_events),
+  delta_head AS (SELECT coalesce(max(cursorId), 0) AS streamHead FROM span_events WHERE parentSpanId IS NULL),
   delta_rows AS (
     SELECT * FROM candidates
     WHERE deltaWatermark > CAST(? AS BIGINT) ${watermark === void 0 ? "AND FALSE" : ""}
@@ -3331,7 +3392,7 @@ ORDER BY delta_rows.deltaWatermark ASC NULLS LAST, delta_rows.traceId ASC`,
     SELECT COUNT(*) AS total
     FROM candidates
   )
-SELECT page_rows.*, page_total.total${deltaPollingFeatureEnabled() ? ", (SELECT coalesce(max(cursorId), 0) FROM root_events) AS streamHead" : ""}
+SELECT page_rows.*, page_total.total${deltaPollingFeatureEnabled() ? ", (SELECT coalesce(max(cursorId), 0) FROM span_events WHERE parentSpanId IS NULL) AS streamHead" : ""}
 FROM page_total
 LEFT JOIN page_rows ON TRUE
 ORDER BY page_rows.__row_position ASC NULLS LAST`,
@@ -3357,12 +3418,7 @@ LIMIT ?`,
 function compileDuckDBThreadQuery(plan) {
 	const relatedCollections = collectRelatedCollections(plan.traces.where);
 	collectThreadRelatedCollections(plan.where, relatedCollections);
-	const { ctes, values: scopeValues } = compileDuckDBTraceScope(relatedCollections, plan.scope);
-	const values = [
-		plan.traces.timeRange.from,
-		plan.traces.timeRange.to,
-		...scopeValues
-	];
+	const { ctes, values } = compileDuckDBTraceScope(relatedCollections, plan.scope, plan.traces.timeRange);
 	let eligibilitySql = "TRUE";
 	if (plan.traces.where) {
 		const eligibility = compilePredicate(plan.traces.where);
@@ -3420,12 +3476,7 @@ function discoveryCollections(scope) {
 	return scope === "trace" ? /* @__PURE__ */ new Set() : /* @__PURE__ */ new Set([scope]);
 }
 function compileDuckDBTraceQueryObservedFields(plan) {
-	const { ctes, values: scopeValues } = compileDuckDBTraceScope(/* @__PURE__ */ new Set(), plan.scope);
-	const values = [
-		plan.timeRange.from,
-		plan.timeRange.to,
-		...scopeValues
-	];
+	const { ctes, values } = compileDuckDBTraceScope(/* @__PURE__ */ new Set(), plan.scope, plan.timeRange);
 	if (plan.search) values.push(plan.search);
 	values.push(plan.limit + 1);
 	const search = plan.search ? `AND strpos(lower('metadata.' || entry.key), lower(?)) > 0` : "";
@@ -3447,12 +3498,7 @@ LIMIT ?`,
 	};
 }
 function compileDuckDBTraceQueryValues(plan) {
-	const { ctes, values: scopeValues } = compileDuckDBTraceScope(discoveryCollections(plan.predicateScope), plan.scope);
-	const values = [
-		plan.timeRange.from,
-		plan.timeRange.to,
-		...scopeValues
-	];
+	const { ctes, values } = compileDuckDBTraceScope(discoveryCollections(plan.predicateScope), plan.scope, plan.timeRange);
 	let fieldSql;
 	let source = discoverySource(plan.predicateScope);
 	if (plan.predicateScope === "trace" && plan.path === "tags") {
@@ -3620,6 +3666,367 @@ async function queryThreads(db, plan) {
 		}) : null }
 	});
 }
+/** Compile a span-row filter with exactly the same rules as trace span predicates. */
+function compileSpanQueryPredicate(predicate) {
+	return compileScalarPredicate(predicate, SPAN_FIELDS);
+}
+//#endregion
+//#region src/storage/domains/observability/span-query.ts
+const identityFields = [
+	"organizationId",
+	"resourceId",
+	"traceId",
+	"spanId"
+];
+const identities = identityFields.join(", ");
+const fields = [
+	...identityFields,
+	"parentSpanId",
+	"name",
+	"spanType",
+	"entityType",
+	"entityId",
+	"entityName",
+	"entityVersionId",
+	"parentEntityVersionId",
+	"rootEntityVersionId",
+	"runId",
+	"sessionId",
+	"userId"
+];
+function keys(rows, values, alias = "") {
+	return rows.map((row) => `(${identityFields.map((field) => {
+		values.push(row[field]);
+		return `${alias}${field} IS NOT DISTINCT FROM ?`;
+	}).join(" AND ")})`).join(" OR ");
+}
+function afterCursor(plan) {
+	if (!plan.cursor) return {
+		sql: "TRUE",
+		values: []
+	};
+	const cursor = plan.cursor;
+	const comparisons = [`s.${plan.orderBy.field} ${plan.orderBy.direction === "asc" ? ">" : "<"} CAST(? AS TIMESTAMP)`];
+	const values = [cursor.sortValue];
+	for (let i = 0; i < identityFields.length; i++) {
+		const field = identityFields[i];
+		if (cursor[field] === null) continue;
+		const equal = [`s.${plan.orderBy.field} = CAST(? AS TIMESTAMP)`];
+		values.push(cursor.sortValue);
+		for (const prior of identityFields.slice(0, i)) {
+			equal.push(`s.${prior} IS NOT DISTINCT FROM ?`);
+			values.push(cursor[prior]);
+		}
+		values.push(cursor[field]);
+		comparisons.push(`(${equal.join(" AND ")} AND (s.${field} > ? OR s.${field} IS NULL))`);
+	}
+	return {
+		sql: `(${comparisons.join(" OR ")})`,
+		values
+	};
+}
+function compileDuckDBSpanQuery(plan) {
+	const values = [plan.timeRange.from, plan.timeRange.to];
+	const scope = [];
+	if (plan.scope) {
+		scope.push("organizationId = ?");
+		values.push(plan.scope.organizationId);
+		if (plan.scope.resourceId !== void 0) {
+			scope.push("resourceId = ?");
+			values.push(plan.scope.resourceId);
+		}
+	}
+	const predicate = plan.where ? compileSpanQueryPredicate(plan.where) : {
+		sql: "TRUE",
+		values: []
+	};
+	const after = afterCursor(plan);
+	values.push(plan.timeRange.from, plan.timeRange.to, ...predicate.values, ...after.values, plan.limit + 1);
+	const join = identityFields.map((field) => `e.${field} IS NOT DISTINCT FROM c.${field}`).join(" AND ");
+	return {
+		sql: `WITH candidates AS MATERIALIZED (
+    SELECT ${identities} FROM span_events
+    WHERE eventType = 'start' AND timestamp >= CAST(? AS TIMESTAMP) AND timestamp < CAST(? AS TIMESTAMP)
+      ${scope.length ? `AND ${scope.join(" AND ")}` : ""}
+    GROUP BY ${identities}
+  ), ranked AS (
+    SELECT ${fields.map((field) => `e.${field}`).join(", ")},
+      min(e.timestamp) FILTER (WHERE e.eventType = 'start') OVER (PARTITION BY ${identityFields.map((field) => `e.${field}`).join(", ")}) AS startedAt, e.endedAt, e.cursorId,
+      CASE WHEN json_type(e.attributes, '$.model') = 'VARCHAR' THEN json_extract_string(e.attributes, '$.model') END AS model,
+      CASE WHEN json_type(e.attributes, '$.provider') = 'VARCHAR' THEN json_extract_string(e.attributes, '$.provider') END AS provider,
+      date_diff('millisecond', min(e.timestamp) FILTER (WHERE e.eventType = 'start') OVER (PARTITION BY ${identityFields.map((field) => `e.${field}`).join(", ")}), e.endedAt) AS durationMs,
+      CASE WHEN e.error IS NULL THEN 'success' ELSE 'error' END AS status,
+      CASE WHEN e.error IS NULL THEN NULL ELSE 'error' END AS error,
+      row_number() OVER (PARTITION BY ${identityFields.map((field) => `e.${field}`).join(", ")}
+        ORDER BY CASE WHEN e.endedAt IS NULL THEN 1 ELSE 0 END, e.cursorId DESC NULLS LAST, e.endedAt DESC) AS rank
+    FROM span_events e INNER JOIN candidates c ON ${join}
+  )
+  SELECT ${[
+			...identityFields,
+			"parentSpanId",
+			"name",
+			"spanType",
+			"entityType",
+			"entityId",
+			"entityName",
+			"model",
+			"provider",
+			"startedAt",
+			"endedAt",
+			"durationMs",
+			"status",
+			"cursorId"
+		].map((field) => `s.${field}`).join(", ")}
+  FROM ranked s WHERE rank = 1 AND endedAt IS NOT NULL AND startedAt >= CAST(? AS TIMESTAMP) AND startedAt < CAST(? AS TIMESTAMP) AND (${predicate.sql}) AND ${after.sql}
+  ORDER BY s.${plan.orderBy.field} ${plan.orderBy.direction === "asc" ? "ASC" : "DESC"}, ${identityFields.map((field) => `s.${field} ASC NULLS LAST`).join(", ")}
+  LIMIT ?`,
+		values
+	};
+}
+async function querySpans(db, plan) {
+	const deadline = performance.now() + coreStorage.TRACE_QUERY_DEFAULT_TIMEOUT_MS;
+	const query = async (sql, values) => {
+		const remaining = Math.floor(deadline - performance.now());
+		if (remaining <= 0) throw new coreStorage.TraceQueryExecutionError();
+		try {
+			return await db.query(sql, values, remaining);
+		} catch (error) {
+			if (error instanceof DuckDBQueryTimeoutError) throw new coreStorage.TraceQueryExecutionError();
+			if (error instanceof Error && /out of memory/i.test(error.message)) throw new coreStorage.TraceQueryResourceLimitError();
+			throw error;
+		}
+	};
+	const compiled = compileDuckDBSpanQuery(plan);
+	const rows = await query(compiled.sql, compiled.values);
+	const selected = rows.map(({ cursorId: _cursorId, startedAt, endedAt, ...row }) => ({
+		...row,
+		startedAt: startedAt.toISOString(),
+		endedAt: endedAt.toISOString()
+	}));
+	const page = rows.slice(0, plan.limit);
+	if (!page.length) return coreStorage.buildSpanQueryResponse(plan, selected, [], []);
+	const payloadValues = [];
+	const payloadWhere = page.map((row) => {
+		const key = keys([row], payloadValues);
+		payloadValues.push(row.cursorId, row.endedAt);
+		return `(${key} AND cursorId IS NOT DISTINCT FROM ? AND endedAt = ?)`;
+	}).join(" OR ");
+	const payloads = await query(`SELECT DISTINCT ${identities},
+    substring(CAST(input AS VARCHAR), 1, ${coreStorage.SPAN_QUERY_MAX_PREVIEW_CHARACTERS + 1}) AS inputPreview, substring(CAST(output AS VARCHAR), 1, ${coreStorage.SPAN_QUERY_MAX_PREVIEW_CHARACTERS + 1}) AS outputPreview
+    FROM span_events WHERE ${payloadWhere}`, payloadValues);
+	const metricValues = [];
+	const metricWhere = keys(page, metricValues);
+	const metrics = await query(`SELECT ${identities}, name, estimatedCost, costUnit,
+    json_extract_string(costMetadata, '$.allocation') AS allocation,
+    COALESCE(json_exists(costMetadata, '$.error'), false) AS costError
+    FROM metric_events WHERE (${metricWhere}) AND name LIKE 'mastra_model_%'
+    LIMIT ${coreStorage.SPAN_QUERY_MAX_COST_METRICS + 1}`, metricValues);
+	if (metrics.length > coreStorage.SPAN_QUERY_MAX_COST_METRICS) throw new coreStorage.TraceQueryResourceLimitError();
+	return coreStorage.buildSpanQueryResponse(plan, selected, payloads, metrics);
+}
+//#endregion
+//#region src/storage/domains/observability/trace-aggregate.ts
+/** Trace-root column expressions (alias `r`) for each groupable dimension; same values `where` sees. */
+const DIMENSION_SQL = {
+	entityType: "r.entityType",
+	entityName: "r.entityName",
+	environment: "r.environment",
+	status: TRACE_STATUS_SQL,
+	serviceName: "r.serviceName",
+	executionSource: "r.executionSource",
+	threadId: "r.threadId",
+	resourceId: "r.resourceId",
+	userId: "r.userId",
+	sessionId: "r.sessionId",
+	organizationId: "r.organizationId",
+	experimentId: "r.experimentId"
+};
+const PERCENTILES = {
+	"duration.p50": .5,
+	"duration.p90": .9,
+	"duration.p95": .95,
+	"duration.p99": .99
+};
+const COMPARISON_SQL = {
+	eq: "=",
+	ne: "<>",
+	lt: "<",
+	lte: "<=",
+	gt: ">",
+	gte: ">="
+};
+/**
+* Compiles a trusted aggregate plan. The plan's caps are enforced by the planner and trusted here.
+*
+* Every candidate root is first reduced to a `facts` row (dimension values, duration, error flag,
+* countDistinct inputs, bucket) so grouping, measures, and joins only reference plain columns.
+* Without `interval`, groups are filtered, ordered, and limited in one grouped select. With
+* `interval`, a `ranked` CTE ranks groups on whole-window measures, then only the top `limit`
+* groups are expanded into per-bucket rows.
+*
+* Parameters are positional, so `values` is appended in the order placeholders appear in the text.
+*/
+function compileDuckDBTraceAggregate(plan) {
+	const { ctes, values } = compileDuckDBTraceCandidates(plan, "r.*");
+	const dimensionSql = (field) => {
+		if (field.startsWith("metadata.")) return {
+			sql: TRACE_METADATA_VALUE_SQL,
+			values: traceMetadataPathValues(field.slice(9))
+		};
+		const sql = Object.hasOwn(DIMENSION_SQL, field) ? DIMENSION_SQL[field] : void 0;
+		if (sql === void 0) throw new Error(`Unsupported trusted trace-aggregate field: ${field}`);
+		return {
+			sql,
+			values: []
+		};
+	};
+	const distinctSql = (field) => field === "traceId" ? {
+		sql: "r.traceId",
+		values: []
+	} : dimensionSql(field);
+	const dimensionColumns = plan.dimensions.map((_, index) => `d${index}`);
+	const distinctColumns = /* @__PURE__ */ new Map();
+	const factColumns = [];
+	plan.dimensions.forEach((dimension, index) => {
+		const compiled = dimensionSql(dimension);
+		factColumns.push(`CAST(${compiled.sql} AS VARCHAR) AS d${index}`);
+		values.push(...compiled.values);
+	});
+	for (const measure of plan.measures) {
+		if (measure.type !== "countDistinct" || distinctColumns.has(measure.field)) continue;
+		const column = `cd${distinctColumns.size}`;
+		distinctColumns.set(measure.field, column);
+		const compiled = distinctSql(measure.field);
+		factColumns.push(`CAST(${compiled.sql} AS VARCHAR) AS ${column}`);
+		values.push(...compiled.values);
+	}
+	factColumns.push(`CAST(${durationMsSql("r.startedAt", "r.endedAt")} AS DOUBLE) AS durationMs`, `r.error IS NOT NULL AS isError`);
+	if (plan.interval !== void 0) {
+		const intervalMs = coreStorage.TRACE_AGGREGATE_INTERVAL_MS[plan.interval];
+		if (intervalMs === void 0) throw new Error(`Unsupported trusted trace-aggregate interval: ${plan.interval}`);
+		factColumns.push(`epoch_ms((epoch_ms(r.startedAt) // ${intervalMs}) * ${intervalMs}) AS bucket`);
+	}
+	ctes.push(`facts AS (
+    SELECT ${factColumns.join(",\n      ")}
+    FROM candidates r
+  )`);
+	const measureSql = (name, alias = "") => {
+		const column = (name) => `${alias}${name}`;
+		if (name === "count") return "CAST(count(*) AS DOUBLE)";
+		if (name === "errorCount") return `CAST(count_if(${column("isError")}) AS DOUBLE)`;
+		if (name === "errorRate") return `CAST(count_if(${column("isError")}) AS DOUBLE) / count(*)`;
+		if (name === "duration.avg") return `avg(${column("durationMs")})`;
+		if (name === "duration.min") return `min(${column("durationMs")})`;
+		if (name === "duration.max") return `max(${column("durationMs")})`;
+		const percentile = PERCENTILES[name];
+		if (percentile !== void 0) return `quantile_cont(${column("durationMs")}, ${percentile})`;
+		const measure = plan.measures.find((candidate) => candidate.type === "countDistinct" && candidate.name === name);
+		const distinctColumn = measure && distinctColumns.get(measure.field);
+		if (distinctColumn === void 0) throw new Error(`Unsupported trusted trace-aggregate measure: ${name}`);
+		return `CAST(count(DISTINCT ${alias}${distinctColumn}) AS DOUBLE)`;
+	};
+	const havingValues = [];
+	const compileHaving = (predicate) => {
+		if (predicate.type === "boolean") return predicate.args.map((arg) => `(${compileHaving(arg)})`).join(predicate.operator === "and" ? " AND " : " OR ");
+		if (predicate.type === "not") return `NOT (${compileHaving(predicate.arg)})`;
+		const measure = measureSql(predicate.measure);
+		if (predicate.type === "membership") {
+			if (predicate.values.length === 0) return predicate.operator === "in" ? "FALSE" : "TRUE";
+			havingValues.push(...predicate.values);
+			const list = predicate.values.map(() => "CAST(? AS DOUBLE)").join(", ");
+			return `${measure} ${predicate.operator === "in" ? "IN" : "NOT IN"} (${list})`;
+		}
+		const operator = COMPARISON_SQL[predicate.operator];
+		if (operator === void 0) throw new Error(`Unsupported trusted trace-aggregate operator: ${predicate.operator}`);
+		havingValues.push(predicate.value);
+		return `${measure} ${operator} CAST(? AS DOUBLE)`;
+	};
+	const havingSql = ["count(*) > 0", ...plan.having ? [`(${compileHaving(plan.having)})`] : []].join(" AND ");
+	const direction = plan.orderBy.direction === "asc" ? "ASC" : "DESC";
+	let orderTarget;
+	if (plan.orderBy.target === "measure") orderTarget = measureSql(plan.orderBy.measure);
+	else {
+		const index = plan.dimensions.indexOf(plan.orderBy.dimension);
+		if (index === -1) throw new Error(`Unsupported trusted trace-aggregate order dimension: ${plan.orderBy.dimension}`);
+		orderTarget = dimensionColumns[index];
+	}
+	const orderSql = [`${orderTarget} ${direction} NULLS LAST`, ...dimensionColumns.map((column) => `${column} ASC NULLS LAST`)].join(", ");
+	const groupSql = dimensionColumns.length > 0 ? `\nGROUP BY ${dimensionColumns.join(", ")}` : "";
+	if (plan.interval === void 0) {
+		const projected = [...dimensionColumns, ...plan.measures.map((measure, index) => `${measureSql(measure.name)} AS m${index}`)];
+		values.push(...havingValues, plan.limit + 1);
+		return {
+			sql: `WITH ${ctes.join(",\n  ")}
+SELECT ${projected.join(", ")}
+FROM facts${groupSql}
+HAVING ${havingSql}
+ORDER BY ${orderSql}
+LIMIT ?`,
+			values
+		};
+	}
+	ctes.push(`ranked AS (
+    SELECT ${[...dimensionColumns, `row_number() OVER (ORDER BY ${orderSql}) AS rank`].join(", ")}
+    FROM facts${groupSql}
+    HAVING ${havingSql}
+    ORDER BY ${orderSql}
+    LIMIT ?
+  )`);
+	values.push(...havingValues, plan.limit + 1);
+	const joinSql = dimensionColumns.length > 0 ? dimensionColumns.map((column) => `f.${column} IS NOT DISTINCT FROM g.${column}`).join(" AND ") : "TRUE";
+	const projected = [
+		...dimensionColumns.map((column) => `f.${column}`),
+		"f.bucket",
+		...plan.measures.map((measure, index) => `${measureSql(measure.name, "f.")} AS m${index}`),
+		`(SELECT count(*) FROM ranked) > ? AS truncated`
+	];
+	values.push(plan.limit, plan.limit);
+	return {
+		sql: `WITH ${ctes.join(",\n  ")}
+SELECT ${projected.join(", ")}
+FROM facts f
+JOIN ranked g ON ${joinSql}
+WHERE g.rank <= ?
+GROUP BY ${[
+			"g.rank",
+			...dimensionColumns.map((column) => `f.${column}`),
+			"f.bucket"
+		].join(", ")}
+ORDER BY g.rank ASC, f.bucket ASC`,
+		values
+	};
+}
+async function aggregateTraces(db, plan) {
+	const compiled = compileDuckDBTraceAggregate(plan);
+	let result;
+	try {
+		result = await db.query(compiled.sql, compiled.values);
+	} catch (error) {
+		if (isDuckDBResourceLimit(error)) throw new coreStorage.TraceQueryResourceLimitError();
+		throw error;
+	}
+	let truncated;
+	let resultRows;
+	if (plan.interval === void 0) {
+		truncated = result.length > plan.limit;
+		resultRows = result.slice(0, plan.limit);
+	} else {
+		truncated = result[0]?.truncated === true;
+		resultRows = result;
+	}
+	return {
+		rows: resultRows.map((row) => {
+			const shaped = { measures: Object.fromEntries(plan.measures.map((measure, index) => [measure.name, Number(row[`m${index}`])])) };
+			if (plan.dimensions.length > 0) shaped.dimensions = Object.fromEntries(plan.dimensions.map((dimension, index) => {
+				const value = row[`d${index}`];
+				return [dimension, value == null ? null : String(value)];
+			}));
+			if (plan.interval !== void 0) shaped.bucket = asIsoTimestamp(row.bucket);
+			return shaped;
+		}),
+		truncated
+	};
+}
 //#endregion
 //#region src/storage/domains/observability/tracing.ts
 const COLUMNS_SQL = [
@@ -4948,6 +5355,8 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends Observ
 			"tag-discovery",
 			"metric-discovery",
 			"trace-query",
+			"trace-aggregate",
+			...spanQueryFeatures,
 			"trace-query-root-duration",
 			"trace-query-discovery",
 			"thread-query",
@@ -4966,6 +5375,8 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends Observ
 			"metric-discovery",
 			"delta-polling",
 			"trace-query",
+			"trace-aggregate",
+			...spanQueryFeatures,
 			"trace-query-root-duration",
 			"trace-query-discovery",
 			"thread-query",
@@ -5001,9 +5412,15 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends Observ
 	async listTraces(args) {
 		return listTraces(this.db, args);
 	}
+	async querySpans(plan) {
+		return querySpans(this.db, plan);
+	}
 	async queryTraces(plan) {
 		return queryTraces(this.db, plan);
 	}
+	async aggregateTraces(plan) {
+		return aggregateTraces(this.db, plan);
+	}
 	async getTraceQueryObservedFields(plan) {
 		return getTraceQueryObservedFields(this.db, plan);
 	}
@@ -5126,4 +5543,4 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends Observ
 //#endregion
 export { ObservabilityStorageDuckDB };
 
-//# sourceMappingURL=observability-BmLO_YTO.js.map
+//# sourceMappingURL=observability-Bk_y3hof.js.map