@mastra/pg 1.22.0-alpha.3 → 1.22.0-alpha.4

package/dist/index.js

@@ -5021,7 +5021,7 @@ var BackgroundTasksPG = class BackgroundTasksPG extends BackgroundTasksStorage {
 			}
 		});
 	}
-	async updateTask(taskId, update) {
+	async updateTask(taskId, update, options) {
 		const setClauses = [];
 		const params = [];
 		let paramIdx = 1;
@@ -5063,10 +5063,15 @@ var BackgroundTasksPG = class BackgroundTasksPG extends BackgroundTasksStorage {
 			const val = update.completedAt?.toISOString() ?? null;
 			params.push(val, val);
 		}
-		if (setClauses.length === 0) return;
+		if (setClauses.length === 0) return false;
 		const table = getTableName$4(getSchemaName$4(this.#schema));
 		params.push(taskId);
-		await this.#db.client.none(`UPDATE ${table} SET ${setClauses.join(", ")} WHERE "id" = $${paramIdx}`, params);
+		let where = `"id" = $${paramIdx++}`;
+		if (options?.expectedStatus) {
+			where += ` AND "status" = $${paramIdx}`;
+			params.push(options.expectedStatus);
+		}
+		return ((await this.#db.client.query(`UPDATE ${table} SET ${setClauses.join(", ")} WHERE ${where}`, params)).rowCount ?? 0) > 0;
 	}
 	async getTask(taskId) {
 		const table = getTableName$4(getSchemaName$4(this.#schema));
@@ -6711,6 +6716,7 @@ var ExperimentsPG = class ExperimentsPG extends ExperimentsStorage {
 				"tags",
 				"comment",
 				"toolMockReport",
+				"metadata",
 				"organizationId",
 				"projectId",
 				"attempt"
@@ -6907,6 +6913,7 @@ var ExperimentsPG = class ExperimentsPG extends ExperimentsStorage {
 			input: safelyParseJSON(row.input),
 			output: row.output ? safelyParseJSON(row.output) : null,
 			groundTruth: row.groundTruth ? safelyParseJSON(row.groundTruth) : null,
+			metadata: row.metadata ? safelyParseJSON(row.metadata) : null,
 			error: row.error ? safelyParseJSON(row.error) : null,
 			startedAt: ensureDate(row.startedAtZ || row.startedAt),
 			completedAt: ensureDate(row.completedAtZ || row.completedAt),
@@ -7215,6 +7222,7 @@ var ExperimentsPG = class ExperimentsPG extends ExperimentsStorage {
 					input: input.input,
 					output: input.output ?? null,
 					groundTruth: input.groundTruth ?? null,
+					metadata: input.metadata ?? null,
 					error: input.error ?? null,
 					startedAt: input.startedAt.toISOString(),
 					completedAt: input.completedAt.toISOString(),
@@ -7237,6 +7245,7 @@ var ExperimentsPG = class ExperimentsPG extends ExperimentsStorage {
 				input: input.input,
 				output: input.output ?? null,
 				groundTruth: input.groundTruth ?? null,
+				metadata: input.metadata ?? null,
 				error: input.error ?? null,
 				startedAt: input.startedAt,
 				completedAt: input.completedAt,
@@ -7273,9 +7282,9 @@ var ExperimentsPG = class ExperimentsPG extends ExperimentsStorage {
 					const id = crypto.randomUUID();
 					return t.one(`INSERT INTO ${tableName} (
               "id", "experimentId", "itemId", "itemDatasetVersion", "organizationId", "projectId",
-              "input", "output", "groundTruth", "error", "startedAt", "completedAt",
+              "input", "output", "groundTruth", "metadata", "error", "startedAt", "completedAt",
               "retryCount", "attempt", "traceId", "status", "tags", "toolMockReport", "createdAt"
-            ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19)
+            ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20)
             RETURNING *`, [
 						id,
 						input.experimentId,
@@ -7286,6 +7295,7 @@ var ExperimentsPG = class ExperimentsPG extends ExperimentsStorage {
 						JSON.stringify(input.input),
 						input.output != null ? JSON.stringify(input.output) : null,
 						input.groundTruth != null ? JSON.stringify(input.groundTruth) : null,
+						input.metadata != null ? JSON.stringify(input.metadata) : null,
 						input.error != null ? JSON.stringify(input.error) : null,
 						input.startedAt.toISOString(),
 						input.completedAt.toISOString(),
@@ -7300,9 +7310,9 @@ var ExperimentsPG = class ExperimentsPG extends ExperimentsStorage {
 				}
 				return t.one(`UPDATE ${tableName} SET
             "itemDatasetVersion" = $2, "organizationId" = $3, "projectId" = $4,
-            "input" = $5, "output" = $6, "groundTruth" = $7, "error" = $8,
-            "startedAt" = $9, "completedAt" = $10, "retryCount" = $11, "attempt" = $12,
-            "traceId" = $13, "status" = $14, "tags" = $15, "toolMockReport" = $16
+            "input" = $5, "output" = $6, "groundTruth" = $7, "metadata" = $8, "error" = $9,
+            "startedAt" = $10, "completedAt" = $11, "retryCount" = $12, "attempt" = $13,
+            "traceId" = $14, "status" = $15, "tags" = $16, "toolMockReport" = $17
           WHERE "id" = $1 RETURNING *`, [
 					existing.id,
 					input.itemDatasetVersion ?? null,
@@ -7311,6 +7321,7 @@ var ExperimentsPG = class ExperimentsPG extends ExperimentsStorage {
 					JSON.stringify(input.input),
 					input.output != null ? JSON.stringify(input.output) : null,
 					input.groundTruth != null ? JSON.stringify(input.groundTruth) : null,
+					input.metadata != null ? JSON.stringify(input.metadata) : null,
 					input.error != null ? JSON.stringify(input.error) : null,
 					input.startedAt.toISOString(),
 					input.completedAt.toISOString(),
@@ -14417,6 +14428,7 @@ function allIndexDDL(schema) {
 //#endregion
 //#region src/storage/domains/observability/v-next/discovery.ts
 const DEFAULT_TTL_SECONDS = 300;
+const DEFAULT_LOOKBACK_SECONDS = 720 * 60 * 60;
 /** All signal tables that contain a column. Used by cross-signal discovery. */
 const SIGNAL_TABLES_WITH_CONTEXT = [
 	TABLE_SPAN_EVENTS,
@@ -14481,22 +14493,71 @@ function startOrJoinRefresh(dedupeKey, cacheKey, refresh, upsert, logger) {
 async function readWithRefresh(client, schema, cacheKey, refresh, ttlSeconds, logger) {
 	const table = qualifiedTable(schema, TABLE_DISCOVERY);
 	const row = await client.oneOrNone(`SELECT "values", "refreshedAt" FROM ${table} WHERE "cacheKey" = $1`, [cacheKey]);
-	const refreshedAtMs = row ? new Date(row.refreshedAt).getTime() : 0;
-	if (!(!row || Date.now() - refreshedAtMs > ttlSeconds * 1e3)) return row.values;
-	const refreshing = startOrJoinRefresh(`${schema}:${cacheKey}`, cacheKey, refresh, (values) => upsertCache(client, schema, cacheKey, values), logger);
+	const dedupeKey = `${schema}:${cacheKey}`;
+	const startRefresh = () => startOrJoinRefresh(dedupeKey, cacheKey, refresh, (values) => upsertCache(client, schema, cacheKey, values), logger);
 	if (ttlSeconds <= 0) try {
-		return await refreshing;
+		return await startRefresh();
 	} catch {
 		return row?.values ?? [];
 	}
+	const refreshedAtMs = row ? new Date(row.refreshedAt).getTime() : 0;
+	if (!(!row || Date.now() - refreshedAtMs > ttlSeconds * 1e3)) return row.values;
 	if (!row) try {
-		return await refreshing;
+		return await startRefresh();
 	} catch {
 		return [];
 	}
-	refreshing.catch(() => {});
+	const previousRefreshedAt = row.refreshedAt;
+	claimRefresh(client, schema, cacheKey, ttlSeconds).then((claimedAt) => {
+		if (!claimedAt) return;
+		return startRefresh().then(() => {}, () => releaseClaim(client, schema, cacheKey, previousRefreshedAt, claimedAt));
+	}).catch(() => {});
 	return row.values;
 }
+/**
+* Try to become the process that refreshes `cacheKey`.
+*
+* The conditional UPDATE re-checks staleness in the database and stamps
+* `refreshedAt` in the same statement, so exactly one caller can transition a
+* given cache row out of the stale window — losers see zero rows updated and
+* skip their refresh. This is the cross-process counterpart to
+* `inFlightRefreshes`: N frontends going stale together run one refresh
+* instead of N.
+*
+* It reuses the cache table rather than an advisory lock because `DbClient`
+* is pool-backed, so a transaction-scoped lock would mean threading explicit
+* transaction handling through the discovery read path.
+*
+* The stamp is provisional in both directions: a completed refresh overwrites
+* it via `upsertCache`, and a failed one restores it via `releaseClaim`.
+*
+* Returns the exact provisional stamp written by the claim (or `null` when
+* the claim was lost) so `releaseClaim` can restore the row only while it
+* still holds this claim's stamp.
+*/
+async function claimRefresh(client, schema, cacheKey, ttlSeconds) {
+	const table = qualifiedTable(schema, TABLE_DISCOVERY);
+	return (await client.oneOrNone(`UPDATE ${table} SET "refreshedAt" = NOW()
+      WHERE "cacheKey" = $1 AND "refreshedAt" <= NOW() - ($2 || ' seconds')::interval
+     RETURNING "refreshedAt"::text AS "refreshedAt"`, [cacheKey, Math.floor(ttlSeconds)]))?.refreshedAt ?? null;
+}
+/**
+* Hand back a claim whose refresh failed by restoring the timestamp the
+* claiming reader observed. Guarded on the row still holding this claim's
+* exact provisional stamp so a refresh that completed in the meantime
+* (another process, or a later claim) isn't dragged backwards into staleness.
+*/
+async function releaseClaim(client, schema, cacheKey, previousRefreshedAt, claimedAt) {
+	const table = qualifiedTable(schema, TABLE_DISCOVERY);
+	try {
+		await client.query(`UPDATE ${table} SET "refreshedAt" = $2
+        WHERE "cacheKey" = $1 AND "refreshedAt" = $3::timestamptz`, [
+			cacheKey,
+			previousRefreshedAt,
+			claimedAt
+		]);
+	} catch {}
+}
 async function upsertCache(client, schema, cacheKey, values) {
 	const table = qualifiedTable(schema, TABLE_DISCOVERY);
 	await client.query(`INSERT INTO ${table} ("cacheKey", "refreshedAt", "values")
@@ -14505,61 +14566,95 @@ async function upsertCache(client, schema, cacheKey, values) {
        "refreshedAt" = EXCLUDED."refreshedAt",
        "values" = EXCLUDED."values"`, [cacheKey, JSON.stringify(values)]);
 }
-async function distinctAcrossTables(client, schema, column, tables, filterSql = "", filterParams = []) {
+/**
+* Time predicate that bounds a discovery refresh to recent events.
+*
+* Each signal table is range-partitioned on its own time column
+* (`SIGNAL_TIME_COLUMN`: `endedAt` for spans, `timestamp` for everything
+* else), so the predicate has to be built per table rather than shared across
+* a UNION. Bounding on that exact column is what lets the planner prune
+* partitions/chunks instead of scanning all history.
+*
+* The interval is interpolated rather than bound to a parameter on purpose:
+* the UNION branches in `distinctAcrossTables` and `getTags` all reference the
+* same positional placeholders, so adding a per-branch parameter would break
+* `$N` numbering. Safety comes from coercing to a finite integer here — the
+* value originates from `DiscoveryConfig`, never from user input.
+*/
+function lookbackPredicate(table, lookbackSeconds) {
+	if (!Number.isFinite(lookbackSeconds) || lookbackSeconds <= 0) return "";
+	const seconds = Math.floor(lookbackSeconds);
+	const timeColumn = SIGNAL_TIME_COLUMN[table];
+	if (!timeColumn) return "";
+	return `AND "${timeColumn}" >= NOW() - INTERVAL '${seconds} seconds'`;
+}
+async function distinctAcrossTables(client, schema, column, tables, lookbackSeconds, filterSql = "", filterParams = []) {
 	const safeColumn = parseSqlIdentifier(column, "column name");
-	const unions = tables.map((t) => `SELECT DISTINCT "${safeColumn}" AS v FROM ${qualifiedTable(schema, t)} WHERE "${safeColumn}" IS NOT NULL AND "${safeColumn}" <> '' ${filterSql}`).join(" UNION ");
+	const unions = tables.map((t) => `SELECT DISTINCT "${safeColumn}" AS v FROM ${qualifiedTable(schema, t)} WHERE "${safeColumn}" IS NOT NULL AND "${safeColumn}" <> '' ${filterSql} ${lookbackPredicate(t, lookbackSeconds)}`).join(" UNION ");
 	return (await client.manyOrNone(`SELECT v FROM (${unions}) sub ORDER BY v`, filterParams)).map((r) => r.v);
 }
 async function getEntityTypes(client, schema, _args, config) {
-	return { entityTypes: await readWithRefresh(client, schema, "entity_types", () => distinctAcrossTables(client, schema, "entityType", ENTITY_DISCOVERY_TABLES), config.ttlSeconds ?? DEFAULT_TTL_SECONDS, config.logger) };
+	const ttl = config.ttlSeconds ?? DEFAULT_TTL_SECONDS;
+	const lookback = config.lookbackSeconds ?? DEFAULT_LOOKBACK_SECONDS;
+	return { entityTypes: await readWithRefresh(client, schema, "entity_types", () => distinctAcrossTables(client, schema, "entityType", ENTITY_DISCOVERY_TABLES, lookback), ttl, config.logger) };
 }
 async function getEntityNames(client, schema, args, config) {
 	const ttl = config.ttlSeconds ?? DEFAULT_TTL_SECONDS;
+	const lookback = config.lookbackSeconds ?? DEFAULT_LOOKBACK_SECONDS;
 	const cacheKey = args.entityType ? `entity_names:${args.entityType}` : "entity_names";
 	const filterSql = args.entityType ? `AND "entityType" = $1` : "";
 	const filterParams = args.entityType ? [args.entityType] : [];
-	return { names: await readWithRefresh(client, schema, cacheKey, () => distinctAcrossTables(client, schema, "entityName", ENTITY_DISCOVERY_TABLES, filterSql, filterParams), ttl, config.logger) };
+	return { names: await readWithRefresh(client, schema, cacheKey, () => distinctAcrossTables(client, schema, "entityName", ENTITY_DISCOVERY_TABLES, lookback, filterSql, filterParams), ttl, config.logger) };
 }
 async function getServiceNames(client, schema, _args, config) {
-	return { serviceNames: await readWithRefresh(client, schema, "service_names", () => distinctAcrossTables(client, schema, "serviceName", SIGNAL_TABLES_WITH_CONTEXT), config.ttlSeconds ?? DEFAULT_TTL_SECONDS, config.logger) };
+	const ttl = config.ttlSeconds ?? DEFAULT_TTL_SECONDS;
+	const lookback = config.lookbackSeconds ?? DEFAULT_LOOKBACK_SECONDS;
+	return { serviceNames: await readWithRefresh(client, schema, "service_names", () => distinctAcrossTables(client, schema, "serviceName", SIGNAL_TABLES_WITH_CONTEXT, lookback), ttl, config.logger) };
 }
 async function getEnvironments(client, schema, _args, config) {
-	return { environments: await readWithRefresh(client, schema, "environments", () => distinctAcrossTables(client, schema, "environment", SIGNAL_TABLES_WITH_CONTEXT), config.ttlSeconds ?? DEFAULT_TTL_SECONDS, config.logger) };
+	const ttl = config.ttlSeconds ?? DEFAULT_TTL_SECONDS;
+	const lookback = config.lookbackSeconds ?? DEFAULT_LOOKBACK_SECONDS;
+	return { environments: await readWithRefresh(client, schema, "environments", () => distinctAcrossTables(client, schema, "environment", SIGNAL_TABLES_WITH_CONTEXT, lookback), ttl, config.logger) };
 }
 async function getTags(client, schema, args, config) {
 	const ttl = config.ttlSeconds ?? DEFAULT_TTL_SECONDS;
+	const lookback = config.lookbackSeconds ?? DEFAULT_LOOKBACK_SECONDS;
 	const cacheKey = args.entityType ? `tags:${args.entityType}` : "tags";
 	const refresh = async () => {
 		const filter = args.entityType ? `AND "entityType" = $1` : "";
 		const params = args.entityType ? [args.entityType] : [];
-		const unions = ENTITY_DISCOVERY_TABLES.map((t) => `SELECT DISTINCT UNNEST("tags") AS v FROM ${qualifiedTable(schema, t)} WHERE array_length("tags", 1) > 0 ${filter}`).join(" UNION ");
+		const unions = ENTITY_DISCOVERY_TABLES.map((t) => `SELECT DISTINCT UNNEST("tags") AS v FROM ${qualifiedTable(schema, t)} WHERE array_length("tags", 1) > 0 ${filter} ${lookbackPredicate(t, lookback)}`).join(" UNION ");
 		return (await client.manyOrNone(`SELECT v FROM (${unions}) sub WHERE v IS NOT NULL AND v <> '' ORDER BY v`, params)).map((r) => r.v);
 	};
 	return { tags: await readWithRefresh(client, schema, cacheKey, refresh, ttl, config.logger) };
 }
 async function getMetricNames(client, schema, args, config) {
+	const ttl = config.ttlSeconds ?? DEFAULT_TTL_SECONDS;
+	const lookback = config.lookbackSeconds ?? DEFAULT_LOOKBACK_SECONDS;
 	let filtered = await readWithRefresh(client, schema, "metric_names", async () => {
 		return (await client.manyOrNone(`SELECT DISTINCT "name" AS v FROM ${qualifiedTable(schema, TABLE_METRIC_EVENTS)}
-         WHERE "name" IS NOT NULL AND "name" <> '' ORDER BY "name"`)).map((r) => r.v);
-	}, config.ttlSeconds ?? DEFAULT_TTL_SECONDS, config.logger);
+         WHERE "name" IS NOT NULL AND "name" <> '' ${lookbackPredicate(TABLE_METRIC_EVENTS, lookback)} ORDER BY "name"`)).map((r) => r.v);
+	}, ttl, config.logger);
 	if (args.prefix) filtered = filtered.filter((v) => v.startsWith(args.prefix));
 	if (args.limit) filtered = filtered.slice(0, args.limit);
 	return { names: filtered };
 }
 async function getMetricLabelKeys(client, schema, args, config) {
 	const ttl = config.ttlSeconds ?? DEFAULT_TTL_SECONDS;
+	const lookback = config.lookbackSeconds ?? DEFAULT_LOOKBACK_SECONDS;
 	return { keys: await readWithRefresh(client, schema, `metric_label_keys:${args.metricName}`, async () => {
 		return (await client.manyOrNone(`SELECT DISTINCT k AS v
          FROM ${qualifiedTable(schema, TABLE_METRIC_EVENTS)}, jsonb_object_keys("labels") k
-         WHERE "name" = $1 ORDER BY k`, [args.metricName])).map((r) => r.v);
+         WHERE "name" = $1 ${lookbackPredicate(TABLE_METRIC_EVENTS, lookback)} ORDER BY k`, [args.metricName])).map((r) => r.v);
 	}, ttl, config.logger) };
 }
 async function getMetricLabelValues(client, schema, args, config) {
 	const ttl = config.ttlSeconds ?? DEFAULT_TTL_SECONDS;
+	const lookback = config.lookbackSeconds ?? DEFAULT_LOOKBACK_SECONDS;
 	let filtered = await readWithRefresh(client, schema, `metric_label_values:${args.metricName}:${args.labelKey}`, async () => {
 		return (await client.manyOrNone(`SELECT DISTINCT "labels" ->> $2 AS v
          FROM ${qualifiedTable(schema, TABLE_METRIC_EVENTS)}
-         WHERE "name" = $1 AND "labels" ? $2
+         WHERE "name" = $1 AND "labels" ? $2 ${lookbackPredicate(TABLE_METRIC_EVENTS, lookback)}
          ORDER BY v`, [args.metricName, args.labelKey])).map((r) => r.v).filter((v) => v != null && v !== "");
 	}, ttl, config.logger);
 	if (args.prefix) filtered = filtered.filter((v) => v.startsWith(args.prefix));
@@ -21907,7 +22002,7 @@ var PgFactoryStorageOps = class {
 					row[name] = Boolean(value);
 					break;
 				case "json":
-					row[name] = typeof value === "string" ? JSON.parse(value) : value;
+					row[name] = value;
 					break;
 				case "bigint":
 				case "integer":