@mastra/duckdb 1.12.1 → 1.13.0-alpha.0

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

@@ -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") {
@@ -3621,6 +3667,209 @@ async function queryThreads(db, plan) {
 	});
 }
 //#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 = [
 	"eventType",
@@ -4948,6 +5197,7 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends Observ
 			"tag-discovery",
 			"metric-discovery",
 			"trace-query",
+			"trace-aggregate",
 			"trace-query-root-duration",
 			"trace-query-discovery",
 			"thread-query",
@@ -4966,6 +5216,7 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends Observ
 			"metric-discovery",
 			"delta-polling",
 			"trace-query",
+			"trace-aggregate",
 			"trace-query-root-duration",
 			"trace-query-discovery",
 			"thread-query",
@@ -5004,6 +5255,9 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends Observ
 	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 +5380,4 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends Observ
 //#endregion
 export { ObservabilityStorageDuckDB };
 
-//# sourceMappingURL=observability-BmLO_YTO.js.map
+//# sourceMappingURL=observability-TpgAucZM.js.map