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

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @mastra/pg
 
+## 1.22.0-alpha.4
+
+### Patch Changes
+
+- Stop observability filter discovery from re-scanning all history on every refresh ([#22136](https://github.com/mastra-ai/mastra/pull/22136))
+
+  Discovery queries that build Studio's Traces, Logs, and Metrics filter suggestions scanned every span, metric, and log event each time the cache went stale, which grew unbounded with retained data. Refreshes are now bounded to the last 30 days by default (configurable via `observability.discovery.lookbackSeconds`, `0` restores the previous unbounded behaviour), so the planner can prune partitions instead of reading all of them. Only one process refreshes a given cache entry at a time, so running several server instances no longer multiplies the work, and Studio holds discovery results for five minutes instead of refetching on every page mount.
+
+- Experiment results now include isolated metadata snapshots from the dataset items that ran. ([#22005](https://github.com/mastra-ai/mastra/pull/22005))
+
+- Fix `PgFactoryStorage` reads of `json` columns holding a JSON value that isn't an object. ([#22258](https://github.com/mastra-ai/mastra/pull/22258))
+
+  node-pg parses JSONB through its own type parsers, so the value reaching row deserialization is already a JS value. Deserialization parsed it a second time when it was a string, which threw and failed the whole read. Objects and arrays came back as JS objects and never hit that branch, so the defect stayed hidden until a caller stored a string.
+
+  This surfaced through Factory credential encryption, which stores secrets as an opaque envelope string: saving or reading any credential on Postgres threw `Unexpected token ... is not valid JSON`, affecting model provider credentials, integrations, and custom providers. libsql was unaffected, since it stores `json` columns as text where parsing on read is correct.
+
+- Enforce atomic conditional background task state updates so cancellation cannot be overwritten during dispatch. Background task storage is no longer exposed by Cloudflare KV or ClickHouse, which cannot provide the required compare-and-set semantics. ([#22228](https://github.com/mastra-ai/mastra/pull/22228))
+
+- Updated dependencies [[`aa3a85d`](https://github.com/mastra-ai/mastra/commit/aa3a85daf094c683bb97efdf4b6a696d2e474af5), [`d29d06f`](https://github.com/mastra-ai/mastra/commit/d29d06fe00bbd35b4571150ea04c59d2ed783c71), [`e6516df`](https://github.com/mastra-ai/mastra/commit/e6516dfcdae4f4ac0e7971d84359a81385ee602f), [`0b2a3d1`](https://github.com/mastra-ai/mastra/commit/0b2a3d1783875c5b97b7b36ab3d03d7360e0dde7), [`6bb5d71`](https://github.com/mastra-ai/mastra/commit/6bb5d7193fe9166b219f0fccae17db7a5ae86e65), [`57de7d6`](https://github.com/mastra-ai/mastra/commit/57de7d644ba7146edb4e9e6111ec4fa98c3a59e9), [`e8e299c`](https://github.com/mastra-ai/mastra/commit/e8e299cc6abdfc39947e2fec25803493015d3882), [`edfc548`](https://github.com/mastra-ai/mastra/commit/edfc548886bc7bae17b681f8b6b41a47eb32bcd2), [`a8a4871`](https://github.com/mastra-ai/mastra/commit/a8a4871215f51da95c47129602157ce5372f634a), [`5165cdc`](https://github.com/mastra-ai/mastra/commit/5165cdcdcf50e144bb8113278535196cc9b07065), [`6bb5d71`](https://github.com/mastra-ai/mastra/commit/6bb5d7193fe9166b219f0fccae17db7a5ae86e65), [`9ee8120`](https://github.com/mastra-ai/mastra/commit/9ee8120ce17f76b9f617489e05a283353742690a), [`d975e92`](https://github.com/mastra-ai/mastra/commit/d975e924d4936f46c386bd3dee39c671720289f6), [`1cfa878`](https://github.com/mastra-ai/mastra/commit/1cfa8784d8da0dfaa0317e5048bc48b6084a5ea5), [`c118318`](https://github.com/mastra-ai/mastra/commit/c1183181c9804303db4b511c2e2648f8b714712b), [`fc07c64`](https://github.com/mastra-ai/mastra/commit/fc07c6465043e08e99193a6751a01c56ffc2e7a1), [`542dee2`](https://github.com/mastra-ai/mastra/commit/542dee254167f974ff8cbbbfc0ce10f9a2616a7b), [`a58483c`](https://github.com/mastra-ai/mastra/commit/a58483cff1a9d41fce7c931843f48cb0ac450f64), [`a58483c`](https://github.com/mastra-ai/mastra/commit/a58483cff1a9d41fce7c931843f48cb0ac450f64), [`895e9df`](https://github.com/mastra-ai/mastra/commit/895e9dfc17d6f34299eca64e317ded9e5f5e5ef8)]:
+  - @mastra/core@1.62.0-alpha.8
+
 ## 1.22.0-alpha.3
 
 ### Minor Changes

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-pg
 description: Documentation for @mastra/pg. Use when working with @mastra/pg APIs, configuration, or implementation.
 metadata:
   package: "@mastra/pg"
-  version: "1.22.0-alpha.3"
+  version: "1.22.0-alpha.4"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.22.0-alpha.3",
+  "version": "1.22.0-alpha.4",
   "package": "@mastra/pg",
   "exports": {},
   "modules": {}

package/dist/docs/references/docs-storage.md

@@ -197,6 +197,7 @@ Each provider page includes installation instructions, configuration parameters,
 - [Convex](https://mastra.ai/integrations/databases/convex)
 - [DuckDB](https://mastra.ai/integrations/databases/duckdb)
 - [DynamoDB](https://mastra.ai/integrations/databases/dynamodb)
+- [Elasticsearch](https://mastra.ai/integrations/databases/elasticsearch)
 - [Google Cloud Spanner](https://mastra.ai/integrations/databases/spanner)
 - [LanceDB](https://mastra.ai/integrations/databases/lancedb)
 - [libSQL](https://mastra.ai/integrations/databases/libsql)

package/dist/docs/references/integrations-databases-postgresql.md

@@ -148,6 +148,30 @@ PostgreSQL supports observability and can handle low trace volumes. Throughput c
 
 `PostgresStoreVNext` uses the `event-sourced` [tracing strategy](https://mastra.ai/docs/observability/integrations/exporters/mastra-storage) instead. It writes one row when a span starts and another when it ends, never updating a row in place, and collapses those rows when a trace is read. Writes stay append-only, and traces appear in Studio while the run is still executing.
 
+#### Filter suggestions
+
+Studio's Traces, Logs, and Metrics pages offer filter values (tags, service names, environments, entity names, metric names and labels) discovered from your observability data. Those values are cached in the database and recomputed in the background when the cache goes stale.
+
+To keep the refresh cheap on large datasets, it only scans events from the last 30 days. Values that appear exclusively in older events won't be suggested, though filtering by them still works. Use `discovery` to change the window or how often it refreshes:
+
+```typescript
+import { PostgresStoreVNext } from '@mastra/pg'
+
+const storage = new PostgresStoreVNext({
+  id: 'pg-storage',
+  connectionString: process.env.DATABASE_URL,
+  observability: {
+    connectionString: process.env.OBSERVABILITY_DATABASE_URL,
+    discovery: {
+      lookbackSeconds: 7 * 24 * 60 * 60, // scan the last 7 days; 0 scans all history
+      ttlSeconds: 15 * 60, // refresh at most every 15 minutes
+    },
+  },
+})
+```
+
+Lower `lookbackSeconds` if refreshes are slow, and raise `ttlSeconds` if they run more often than your filter values change. Only one process refreshes a given cache entry at a time, so adding server instances doesn't multiply the work.
+
 ### Initialization
 
 When you pass storage to the Mastra class, `init()` is called automatically before any storage operation:

package/dist/index.cjs

@@ -5045,7 +5045,7 @@ var BackgroundTasksPG = class BackgroundTasksPG extends _mastra_core_storage.Bac
 			}
 		});
 	}
-	async updateTask(taskId, update) {
+	async updateTask(taskId, update, options) {
 		const setClauses = [];
 		const params = [];
 		let paramIdx = 1;
@@ -5087,10 +5087,15 @@ var BackgroundTasksPG = class BackgroundTasksPG extends _mastra_core_storage.Bac
 			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));
@@ -6735,6 +6740,7 @@ var ExperimentsPG = class ExperimentsPG extends _mastra_core_storage.Experiments
 				"tags",
 				"comment",
 				"toolMockReport",
+				"metadata",
 				"organizationId",
 				"projectId",
 				"attempt"
@@ -6931,6 +6937,7 @@ var ExperimentsPG = class ExperimentsPG extends _mastra_core_storage.Experiments
 			input: (0, _mastra_core_storage.safelyParseJSON)(row.input),
 			output: row.output ? (0, _mastra_core_storage.safelyParseJSON)(row.output) : null,
 			groundTruth: row.groundTruth ? (0, _mastra_core_storage.safelyParseJSON)(row.groundTruth) : null,
+			metadata: row.metadata ? (0, _mastra_core_storage.safelyParseJSON)(row.metadata) : null,
 			error: row.error ? (0, _mastra_core_storage.safelyParseJSON)(row.error) : null,
 			startedAt: (0, _mastra_core_storage.ensureDate)(row.startedAtZ || row.startedAt),
 			completedAt: (0, _mastra_core_storage.ensureDate)(row.completedAtZ || row.completedAt),
@@ -7239,6 +7246,7 @@ var ExperimentsPG = class ExperimentsPG extends _mastra_core_storage.Experiments
 					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(),
@@ -7261,6 +7269,7 @@ var ExperimentsPG = class ExperimentsPG extends _mastra_core_storage.Experiments
 				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,
@@ -7297,9 +7306,9 @@ var ExperimentsPG = class ExperimentsPG extends _mastra_core_storage.Experiments
 					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,
@@ -7310,6 +7319,7 @@ var ExperimentsPG = class ExperimentsPG extends _mastra_core_storage.Experiments
 						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(),
@@ -7324,9 +7334,9 @@ var ExperimentsPG = class ExperimentsPG extends _mastra_core_storage.Experiments
 				}
 				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,
@@ -7335,6 +7345,7 @@ var ExperimentsPG = class ExperimentsPG extends _mastra_core_storage.Experiments
 					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(),
@@ -14441,6 +14452,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,
@@ -14505,22 +14517,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")
@@ -14529,61 +14590,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 = (0, _mastra_core_utils.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));
@@ -21931,7 +22026,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":