@oneuptime/common 13.0.4 → 13.0.6

package/build/dist/Server/API/TelemetryAPI.js

@@ -4,6 +4,8 @@ import Response from "../Utils/Response";
 import BadDataException from "../../Types/Exception/BadDataException";
 import CommonAPI from "./CommonAPI";
 import TelemetryType from "../../Types/Telemetry/TelemetryType";
+import { parseExceptionSpanScope } from "../../Types/Telemetry/ExceptionSpanScope";
+import ServiceType from "../../Types/Telemetry/ServiceType";
 import TelemetryAttributeService from "../Services/TelemetryAttributeService";
 import TelemetrySourceMapService from "../Services/TelemetrySourceMapService";
 import SourceMapResolver, { MAX_FRAMES_PER_RESOLVE_REQUEST, } from "../Utils/Telemetry/SourceMapResolver";
@@ -27,6 +29,8 @@ import RumSession from "../../Models/AnalyticsModels/RumSession";
 import ObjectID from "../../Types/ObjectID";
 import OneUptimeDate from "../../Types/Date";
 import ResourceFacetResolver from "../Utils/Telemetry/ResourceFacetResolver";
+import ResourceFacetPlanner from "../Utils/Telemetry/ResourceFacetPlanner";
+import { RESOURCE_FACET_CATALOG_KEYS } from "../../Types/Telemetry/ResourceFacetCatalog";
 import ResourceEntityFilter from "../Utils/Telemetry/ResourceEntityFilter";
 import RumApplicationService from "../Services/RumApplicationService";
 import ProjectService from "../Services/ProjectService";
@@ -35,7 +39,7 @@ import SessionIdentity from "../../Utils/Rum/SessionIdentity";
 import SessionReplayTargeting from "../Utils/SessionReplay/SessionReplayTargeting";
 import SessionReplayUsage from "../Utils/SessionReplay/SessionReplayUsage";
 import RumSessionReplayViewService, { normalizeSecondsWatched, } from "../Services/RumSessionReplayViewService";
-import SessionReplayReadService, { DEFAULT_SESSION_REPLAY_LIST_LIMIT, DEFAULT_SESSION_REPLAY_USERS_LIMIT, MAX_SESSION_REPLAY_FOR_EXCEPTION_LIMIT, MAX_SESSION_REPLAY_LIST_LIMIT, MAX_SESSION_REPLAY_USERS_LIMIT, SESSION_REPLAY_EXCEPTION_WINDOW_PADDING_MS, } from "../Utils/SessionReplay/SessionReplayReadService";
+import SessionReplayReadService, { DEFAULT_SESSION_REPLAY_LIST_LIMIT, DEFAULT_SESSION_REPLAY_USERS_LIMIT, MAX_SESSION_REPLAY_FOR_EXCEPTION_LIMIT, MAX_SESSION_REPLAY_LIST_LIMIT, MAX_SESSION_REPLAY_SESSION_ID_LENGTH, MAX_SESSION_REPLAY_SUMMARIES_BATCH_SIZE, MAX_SESSION_REPLAY_USERS_LIMIT, SESSION_REPLAY_EXCEPTION_WINDOW_PADDING_MS, } from "../Utils/SessionReplay/SessionReplayReadService";
 import SessionReplayHealthCounters from "../Utils/SessionReplay/SessionReplayHealthCounters";
 import { isSessionErased } from "../Utils/SessionReplay/SessionReplayErasureTombstone";
 import NotFoundException from "../../Types/Exception/NotFoundException";
@@ -375,9 +379,10 @@ router.post("/telemetry/logs/facets", ...requireLogReadAccess, async (req, res,
             : undefined;
         /*
          * Per-facet partial-match filter applied at the Postgres source-of-truth
-         * lookup stage. Only consulted for resource facets (primaryEntityId /
-         * hostId / dockerHostId / kubernetesClusterId) — other facets continue
-         * to filter client-side over the loaded value list.
+         * lookup stage. Only consulted for resource facets (primaryEntityId and
+         * every ResourceFacetCatalog key — hostId / kubernetesClusterId / ...)
+         * — other facets continue to filter client-side over the loaded value
+         * list.
          */
         const facetSearchText = body["facetSearchText"]
             ? body["facetSearchText"]
@@ -389,11 +394,21 @@ router.post("/telemetry/logs/facets", ...requireLogReadAccess, async (req, res,
         const projectId = databaseProps.tenantId;
         const resourceScopes = await resolveResourceScopesFromBody(body, projectId);
         /*
-         * Run facet queries in parallel so a slow individual facet can't
-         * starve the endpoint. Per-facet errors degrade gracefully to [].
+         * One ClickHouse GROUP BY per facet, in parallel so a slow facet can't
+         * starve the endpoint; per-facet errors degrade gracefully to [].
+         * Resource facets come back as the Postgres source-of-truth list
+         * (filtered by facetSearchText, enriched with displayName) with those
+         * counts merged in, so low-volume resources stay visible and search
+         * reaches resources outside the window. Their lists are fetched FIRST:
+         * a resource type the project has none of skips its ClickHouse scan
+         * entirely (see ResourceFacetPlanner).
          */
-        const facetResults = await Promise.all(facetKeys.map(async (facetKey) => {
-            try {
+        const facets = await ResourceFacetPlanner.countPerFacet({
+            projectId,
+            facetKeys,
+            facetSearchText,
+            limit,
+            countFacet: (facetKey) => {
                 const request = {
                     projectId,
                     startTime,
@@ -410,43 +425,9 @@ router.post("/telemetry/logs/facets", ...requireLogReadAccess, async (req, res,
                     sessionIds,
                     attributes,
                 };
-                const values = await LogAggregationService.getFacetValues(request);
-                return [facetKey, values];
-            }
-            catch (_a) {
-                return [facetKey, []];
-            }
-        }));
-        const facets = Object.fromEntries(facetResults);
-        /*
-         * Replace resource-facet results with the Postgres source-of-truth list
-         * (filtered by facetSearchText and enriched with displayName). See the
-         * trace facets handler above for the rationale — same pattern, same
-         * benefit: low-volume resources stay visible and search can reach
-         * resources outside the ClickHouse sample window.
-         */
-        const resourceSpecs = facetKeys
-            .filter((key) => {
-            return ResourceFacetResolver.isResourceFacet(key);
-        })
-            .map((key) => {
-            const counts = new Map();
-            for (const fv of facets[key] || []) {
-                counts.set(fv.value, fv.count);
-            }
-            return {
-                facetKey: key,
-                counts,
-                searchText: facetSearchText === null || facetSearchText === void 0 ? void 0 : facetSearchText[key],
-                limit,
-            };
+                return LogAggregationService.getFacetValues(request);
+            },
         });
-        if (resourceSpecs.length > 0) {
-            const resolved = await ResourceFacetResolver.resolve(projectId, resourceSpecs);
-            for (const key of Object.keys(resolved)) {
-                facets[key] = resolved[key];
-            }
-        }
         return Response.sendJsonObjectResponse(req, res, {
             facets: facets,
         });
@@ -457,13 +438,16 @@ router.post("/telemetry/logs/facets", ...requireLogReadAccess, async (req, res,
 });
 /**
  * Resolve the `resourceFilters` field — the explorers' non-Service resource
- * facet selections (Kubernetes cluster / host / docker host / podman host),
- * sent as Postgres ids — into the scopes the aggregation services compile.
+ * facet selections (any ResourceFacetCatalog type: host / Kubernetes cluster
+ * / Proxmox cluster / serverless function / ...), sent as Postgres ids —
+ * into the scopes the aggregation services compile.
  *
  * Kept out of the sync body parsers because turning an id into an entity
  * key needs a Postgres round trip: the id names a row whose identifying
- * value (`clusterIdentifier` / `hostIdentifier`) is what ingest hashed into
- * `entityKeys`.
+ * value (`hostIdentifier` / `clusterIdentifier` / a cluster `name` / ...) is
+ * what ingest hashed into `entityKeys` and stamped as a resource attribute.
+ * Types without such an identity keep an id-only scope (see
+ * ResourceEntityFilter).
  *
  * Returns undefined when nothing was selected so the request field stays
  * absent rather than becoming an empty array.
@@ -525,6 +509,21 @@ function parseAttributeFilterRecord(raw) {
     }
     return filters;
 }
+/*
+ * An exception scope that is present but malformed is a client bug, and
+ * dropping it would silently chart every span in the project under an
+ * exception's heading — so it is refused instead.
+ */
+function parseTraceExceptionScope(raw) {
+    if (raw === undefined || raw === null) {
+        return undefined;
+    }
+    const scope = parseExceptionSpanScope(raw);
+    if (!scope) {
+        throw new BadDataException("exceptionScope must have a fingerprint and, optionally, a primaryEntityId UUID.");
+    }
+    return scope;
+}
 /*
  * Shared body parsing for every trace aggregation endpoint (histogram,
  * facets, analytics). Defensive about shapes: arrays are validated and
@@ -606,6 +605,7 @@ function parseTraceFilterBody(body) {
         hasException: typeof body["hasException"] === "boolean"
             ? body["hasException"]
             : undefined,
+        exceptionScope: parseTraceExceptionScope(body["exceptionScope"]),
         minDurationNano: typeof body["minDurationNano"] === "number"
             ? body["minDurationNano"]
             : undefined,
@@ -670,9 +670,10 @@ router.post("/telemetry/traces/facets", ...requireTraceReadAccess, async (req, r
         const traceFilters = Object.assign(Object.assign({}, parseTraceFilterBody(body)), { resourceScopes: await resolveResourceScopesFromBody(body, databaseProps.tenantId) });
         /*
          * Per-facet partial-match filter applied at the Postgres source-of-truth
-         * lookup stage. Only consulted for resource facets (primaryEntityId /
-         * hostId / dockerHostId / kubernetesClusterId) — other facets continue
-         * to filter client-side over the loaded value list.
+         * lookup stage. Only consulted for resource facets (primaryEntityId and
+         * every ResourceFacetCatalog key — hostId / kubernetesClusterId / ...)
+         * — other facets continue to filter client-side over the loaded value
+         * list.
          */
         const facetSearchText = body["facetSearchText"]
             ? body["facetSearchText"]
@@ -688,9 +689,8 @@ router.post("/telemetry/traces/facets", ...requireTraceReadAccess, async (req, r
             facetKeys,
             limit }, traceFilters);
         /*
-         * Resource facets (primaryEntityId / hostId / dockerHostId / k8s
-         * cluster ...) and statusCode are counted with an exact,
-         * projection-backed GROUP BY
+         * Resource facets (primaryEntityId and every ResourceFacetCatalog key)
+         * and statusCode are counted with an exact, projection-backed GROUP BY
          * in getResourceFacetCounts(). The recent-N sample below saturates with
          * whichever service is chattiest right now and reports 0 for every other
          * service regardless of its true volume over the window — the "top 1000"
@@ -704,10 +704,20 @@ router.post("/telemetry/traces/facets", ...requireTraceReadAccess, async (req, r
                 key !== "isRootSpan" &&
                 key !== "hasException");
         });
-        const needsAccurateCounts = facetKeys.includes("statusCode") ||
-            facetKeys.some((key) => {
-                return ResourceFacetResolver.isResourceFacet(key);
-            });
+        /*
+         * Resource facets list their Postgres rows FIRST. The exact counts are
+         * one shared GROUP BY for statusCode and every resource facet, so it
+         * only runs when statusCode is requested or some requested resource
+         * facet listed a row to merge counts into — a sidebar whose resource
+         * types the project has none of skips the scan entirely. The listing
+         * still overlaps the sample / root-span / exception queries.
+         */
+        const resourceListing = ResourceFacetPlanner.listResourceFacets({
+            projectId: databaseProps.tenantId,
+            facetKeys,
+            facetSearchText,
+            limit,
+        });
         const wantsRootSpan = facetKeys.includes("isRootSpan");
         const wantsHasException = facetKeys.includes("hasException");
         const emptyAccurate = {
@@ -722,7 +732,7 @@ router.post("/telemetry/traces/facets", ...requireTraceReadAccess, async (req, r
          * the projection-backed sample / resource / root-span queries keeps it
          * off the critical path. Each query keeps its own degrade-to-empty catch.
          */
-        const [sampledFacets, accurate, rootSpanCounts, exceptionCounts] = await Promise.all([
+        const [sampledFacets, listedResourceFacets, accurate, rootSpanCounts, exceptionCounts,] = await Promise.all([
             sampledKeys.length > 0
                 ? TraceAggregationService.getFacetValuesFromSample(Object.assign(Object.assign({}, multiRequest), { facetKeys: sampledKeys })).catch(() => {
                     return Object.fromEntries(sampledKeys.map((key) => {
@@ -730,15 +740,22 @@ router.post("/telemetry/traces/facets", ...requireTraceReadAccess, async (req, r
                     }));
                 })
                 : Promise.resolve({}),
-            needsAccurateCounts
-                ? TraceAggregationService.getResourceFacetCounts(multiRequest).catch(() => {
+            resourceListing,
+            resourceListing.then((listed) => {
+                if (!ResourceFacetPlanner.needsTraceResourceFacetCounts({
+                    facetKeys,
+                    listed,
+                })) {
+                    return Promise.resolve(emptyAccurate);
+                }
+                return TraceAggregationService.getResourceFacetCounts(multiRequest).catch(() => {
                     /*
                      * Degrade gracefully: resource facets still enumerate via
                      * Postgres (count 0), statusCode falls back to empty.
                      */
                     return emptyAccurate;
-                })
-                : Promise.resolve(emptyAccurate),
+                });
+            }),
             wantsRootSpan
                 ? TraceAggregationService.getRootSpanCounts(multiRequest).catch(() => {
                     return null;
@@ -790,31 +807,23 @@ router.post("/telemetry/traces/facets", ...requireTraceReadAccess, async (req, r
                 : [];
         }
         /*
-         * Replace resource-facet results with the Postgres source-of-truth list
+         * Resource facets answer with the Postgres source-of-truth list
          * (filtered by facetSearchText and enriched with displayName). Every
          * resource facet shares the same exact primaryEntityId -> count map;
          * resource ids are globally unique, so each facet only ever resolves its own
          * entities. Entities with no telemetry in the window surface with count
          * 0 instead of being hidden, and the search box can find resources
-         * beyond the loaded subset.
+         * beyond the loaded subset. A facet that listed nothing answers [].
          */
-        const resourceSpecs = facetKeys
-            .filter((key) => {
-            return ResourceFacetResolver.isResourceFacet(key);
-        })
-            .map((key) => {
-            return {
-                facetKey: key,
-                counts: serviceCounts,
-                searchText: facetSearchText === null || facetSearchText === void 0 ? void 0 : facetSearchText[key],
-                limit,
-            };
+        const resourceFacets = ResourceFacetPlanner.mergeResourceFacetCounts({
+            facetKeys,
+            listed: listedResourceFacets,
+            countsFor: () => {
+                return serviceCounts;
+            },
         });
-        if (resourceSpecs.length > 0) {
-            const resolved = await ResourceFacetResolver.resolve(databaseProps.tenantId, resourceSpecs);
-            for (const key of Object.keys(resolved)) {
-                facets[key] = resolved[key];
-            }
+        for (const key of Object.keys(resourceFacets)) {
+            facets[key] = resourceFacets[key] || [];
         }
         return Response.sendJsonObjectResponse(req, res, {
             facets: facets,
@@ -966,10 +975,7 @@ router.post("/telemetry/exceptions/facets", ...requireExceptionReadAccess, async
             ? body["facetKeys"]
             : [
                 "primaryEntityId",
-                "hostId",
-                "dockerHostId",
-                "podmanHostId",
-                "kubernetesClusterId",
+                ...RESOURCE_FACET_CATALOG_KEYS,
                 "exceptionType",
                 "environment",
             ];
@@ -1011,11 +1017,19 @@ router.post("/telemetry/exceptions/facets", ...requireExceptionReadAccess, async
             : undefined;
         const projectId = databaseProps.tenantId;
         /*
-         * Per-facet ClickHouse query in parallel. Per-facet errors degrade
+         * Per-facet ClickHouse query in parallel; per-facet errors degrade
          * gracefully to [] so a slow / failing facet can't block the others.
+         * Resource facets answer with the Postgres source-of-truth list
+         * (filtered by facetSearchText, enriched with displayName), listed
+         * first so a type with no rows skips its count query. Same flow as the
+         * log facets endpoint.
          */
-        const facetResults = await Promise.all(facetKeys.map(async (facetKey) => {
-            try {
+        const facets = await ResourceFacetPlanner.countPerFacet({
+            projectId,
+            facetKeys,
+            facetSearchText,
+            limit,
+            countFacet: (facetKey) => {
                 const request = {
                     projectId,
                     startTime,
@@ -1030,41 +1044,9 @@ router.post("/telemetry/exceptions/facets", ...requireExceptionReadAccess, async
                     escaped,
                     messageSearchText,
                 };
-                const values = await ExceptionAggregationService.getFacetValues(request);
-                return [facetKey, values];
-            }
-            catch (_a) {
-                return [facetKey, []];
-            }
-        }));
-        const facets = Object.fromEntries(facetResults);
-        /*
-         * Replace resource-facet results with the Postgres source-of-truth list
-         * (filtered by facetSearchText and enriched with displayName). Same
-         * pattern as the trace/log facets endpoints.
-         */
-        const resourceSpecs = facetKeys
-            .filter((key) => {
-            return ResourceFacetResolver.isResourceFacet(key);
-        })
-            .map((key) => {
-            const counts = new Map();
-            for (const fv of facets[key] || []) {
-                counts.set(fv.value, fv.count);
-            }
-            return {
-                facetKey: key,
-                counts,
-                searchText: facetSearchText === null || facetSearchText === void 0 ? void 0 : facetSearchText[key],
-                limit,
-            };
+                return ExceptionAggregationService.getFacetValues(request);
+            },
         });
-        if (resourceSpecs.length > 0) {
-            const resolved = await ResourceFacetResolver.resolve(projectId, resourceSpecs);
-            for (const key of Object.keys(resolved)) {
-                facets[key] = resolved[key];
-            }
-        }
         return Response.sendJsonObjectResponse(req, res, {
             facets: facets,
         });
@@ -1083,13 +1065,7 @@ router.post("/telemetry/metrics/facets", ...requireMetricReadAccess, async (req,
         const body = req.body;
         const facetKeys = body["facetKeys"]
             ? body["facetKeys"]
-            : [
-                "primaryEntityId",
-                "hostId",
-                "dockerHostId",
-                "podmanHostId",
-                "kubernetesClusterId",
-            ];
+            : ["primaryEntityId", ...RESOURCE_FACET_CATALOG_KEYS];
         const startTime = body["startTime"]
             ? OneUptimeDate.fromString(body["startTime"])
             : OneUptimeDate.addRemoveHours(OneUptimeDate.getCurrentDate(), -1);
@@ -1111,11 +1087,19 @@ router.post("/telemetry/metrics/facets", ...requireMetricReadAccess, async (req,
             : undefined;
         const projectId = databaseProps.tenantId;
         /*
-         * Per-facet ClickHouse GROUP BY in parallel. Per-facet errors degrade
-         * to [] so a slow facet doesn't block the rest.
+         * Per-facet ClickHouse GROUP BY in parallel; per-facet errors degrade
+         * to [] so a slow facet doesn't block the rest. Resource facets answer
+         * with the Postgres source-of-truth list (filtered by facetSearchText,
+         * enriched with displayName), listed first so a type with no rows
+         * skips its count query. Same flow as the log / exception facets
+         * endpoints.
          */
-        const facetResults = await Promise.all(facetKeys.map(async (facetKey) => {
-            try {
+        const facets = await ResourceFacetPlanner.countPerFacet({
+            projectId,
+            facetKeys,
+            facetSearchText,
+            limit,
+            countFacet: (facetKey) => {
                 const request = {
                     projectId,
                     startTime,
@@ -1126,41 +1110,9 @@ router.post("/telemetry/metrics/facets", ...requireMetricReadAccess, async (req,
                     metricNames,
                     attributes,
                 };
-                const values = await MetricAggregationService.getFacetValues(request);
-                return [facetKey, values];
-            }
-            catch (_a) {
-                return [facetKey, []];
-            }
-        }));
-        const facets = Object.fromEntries(facetResults);
-        /*
-         * Replace resource-facet results with the Postgres source-of-truth list
-         * (filtered by facetSearchText and enriched with displayName). Same
-         * pattern as the trace / log / exception facets endpoints.
-         */
-        const resourceSpecs = facetKeys
-            .filter((key) => {
-            return ResourceFacetResolver.isResourceFacet(key);
-        })
-            .map((key) => {
-            const counts = new Map();
-            for (const fv of facets[key] || []) {
-                counts.set(fv.value, fv.count);
-            }
-            return {
-                facetKey: key,
-                counts,
-                searchText: facetSearchText === null || facetSearchText === void 0 ? void 0 : facetSearchText[key],
-                limit,
-            };
+                return MetricAggregationService.getFacetValues(request);
+            },
         });
-        if (resourceSpecs.length > 0) {
-            const resolved = await ResourceFacetResolver.resolve(projectId, resourceSpecs);
-            for (const key of Object.keys(resolved)) {
-                facets[key] = resolved[key];
-            }
-        }
         return Response.sendJsonObjectResponse(req, res, {
             facets: facets,
         });
@@ -2094,7 +2046,7 @@ router.post("/telemetry/profiles/trace-presence", ...requireProfileReadAccess, a
  * Session replay playback
  * ---------------------------------------------------------------------
  *
- * These five routes are the ONLY reader of RumSessionV1 / RumSessionChunkV1:
+ * These routes are the ONLY reader of RumSessionV1 / RumSessionChunkV1:
  * both analytics models deliberately omit `crudApiPath`, so there is no
  * generic CRUD surface for them and ModelPermission is NEVER invoked on
  * this path.
@@ -2176,6 +2128,24 @@ const SESSION_REPLAY_LIST_PERMISSIONS = [
      */
     Permission.ReadRumSessionReplayPayload,
 ];
+/*
+ * The optional audit-table enrichment must admit an audit-only reviewer so a
+ * 403 from the shared browser API does not navigate them away from the audit
+ * page. The handler still returns metadata only after a separate LIST-scope
+ * check for the resolved application; audit access alone receives an empty,
+ * successful response.
+ */
+const SESSION_REPLAY_SUMMARY_PERMISSIONS = [
+    ...SESSION_REPLAY_LIST_PERMISSIONS,
+    Permission.ReadRumSessionReplayAudit,
+];
+const requireSessionReplaySummaryAccess = [
+    UserMiddleware.getUserMiddleware,
+    UserMiddleware.requireUserAuthentication,
+    UserMiddleware.requirePermission({
+        permissions: SESSION_REPLAY_SUMMARY_PERMISSIONS,
+    }),
+];
 const SESSION_REPLAY_PAYLOAD_PERMISSIONS = [
     Permission.ProjectOwner,
     Permission.ProjectAdmin,
@@ -2383,6 +2353,26 @@ const canReadIdentifiedUserLabel = (data) => {
         application: data.application,
     });
 };
+/*
+ * Audit-only roles may load the summaries route so the optional request can
+ * fail closed without a browser-wide forbidden redirect. They still must not
+ * gain the session-list metadata this endpoint projects. Re-evaluate the
+ * list scope against the already-resolved application and turn unsupported
+ * scope shapes into "no metadata" rather than an authorization error.
+ */
+const canReadSessionReplayListMetadata = (data) => {
+    let scope;
+    try {
+        scope = getSessionReplayLabelScope(data.databaseProps, SESSION_REPLAY_LIST_PERMISSIONS);
+    }
+    catch (_a) {
+        return false;
+    }
+    return isApplicationInSessionReplayScope({
+        scope: scope,
+        application: data.application,
+    });
+};
 const resolveAccessibleRumApplicationIds = async (data) => {
     const scope = getSessionReplayLabelScope(data.databaseProps, data.permissions);
     if (scope.isUnrestricted) {
@@ -2618,7 +2608,6 @@ const readObjectIdFromBody = (body, key) => {
  * callers exist - but it is a cap: an unbounded caller-supplied string
  * reaches ClickHouse as a bound parameter on a hot path.
  */
-const MAX_SESSION_REPLAY_SESSION_ID_LENGTH = 128;
 const readSessionIdFromBody = (body) => {
     const sessionId = body["sessionId"];
     if (typeof sessionId !== "string" || sessionId.length === 0) {
@@ -2629,6 +2618,35 @@ const readSessionIdFromBody = (body) => {
     }
     return sessionId;
 };
+/*
+ * The summaries route accepts one audit-table page at a time. Validate the
+ * raw array before de-duplicating it so repeated values cannot be used to
+ * bypass the request-size ceiling, then preserve first-occurrence order.
+ */
+const readSessionIdsFromBody = (body) => {
+    const value = body["sessionIds"];
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new BadDataException("sessionIds must be a non-empty array");
+    }
+    if (value.length > MAX_SESSION_REPLAY_SUMMARIES_BATCH_SIZE) {
+        throw new BadDataException(`sessionIds must contain at most ${MAX_SESSION_REPLAY_SUMMARIES_BATCH_SIZE} ids`);
+    }
+    const sessionIds = [];
+    const seen = new Set();
+    for (const sessionId of value) {
+        if (typeof sessionId !== "string" || sessionId.length === 0) {
+            throw new BadDataException("Every sessionId must be a non-empty string");
+        }
+        if (sessionId.length > MAX_SESSION_REPLAY_SESSION_ID_LENGTH) {
+            throw new BadDataException(`Every sessionId must be at most ${MAX_SESSION_REPLAY_SESSION_ID_LENGTH} characters.`);
+        }
+        if (!seen.has(sessionId)) {
+            seen.add(sessionId);
+            sessionIds.push(sessionId);
+        }
+    }
+    return sessionIds;
+};
 /*
  * Caps on the list's filter inputs.
  *
@@ -2931,6 +2949,51 @@ router.post("/telemetry/rum/session-replay/list", ...requireSessionReplayListAcc
         next(err);
     }
 });
+// --- Session Replay Summary Batch Endpoint ---
+/*
+ * Audit rows store only the session id. Resolve one page of those ids into
+ * compact, non-identity session context. Audit-only callers receive an empty
+ * success; session-list metadata is returned only after the resolved
+ * application passes the list scope. The service performs one
+ * application-pinned argMax query, so this route never turns an audit page
+ * into an N+1 ClickHouse workload.
+ */
+router.post("/telemetry/rum/session-replay/summaries", ...requireSessionReplaySummaryAccess, async (req, res, next) => {
+    try {
+        const databaseProps = await CommonAPI.getDatabaseCommonInteractionProps(req);
+        if (!(databaseProps === null || databaseProps === void 0 ? void 0 : databaseProps.tenantId)) {
+            return Response.sendErrorResponse(req, res, new BadDataException("Invalid Project ID"));
+        }
+        assertSessionReplayPlan(databaseProps);
+        const projectId = databaseProps.tenantId;
+        const body = req.body;
+        const rumApplicationId = readObjectIdFromBody(body, "rumApplicationId");
+        const sessionIds = readSessionIdsFromBody(body);
+        const application = await assertSessionReplayApplicationAccess({
+            projectId: projectId,
+            rumApplicationId: rumApplicationId,
+            databaseProps: databaseProps,
+            permissions: SESSION_REPLAY_SUMMARY_PERMISSIONS,
+        });
+        if (!canReadSessionReplayListMetadata({
+            databaseProps: databaseProps,
+            application: application,
+        })) {
+            return Response.sendJsonObjectResponse(req, res, { sessions: [] });
+        }
+        const sessions = await SessionReplayReadService.getSessionSummaries({
+            projectId: projectId,
+            rumApplicationId: rumApplicationId,
+            sessionIds: sessionIds,
+        });
+        return Response.sendJsonObjectResponse(req, res, {
+            sessions: sessions,
+        });
+    }
+    catch (err) {
+        next(err);
+    }
+});
 // --- Session Replay Users Endpoint ---
 /*
  * The cursor /users emits and accepts: the last row's "last seen" clock
@@ -3536,6 +3599,21 @@ router.post("/telemetry/rum/session-replay/for-exception", ...requireSessionRepl
         if (typeof fingerprint !== "string" || fingerprint.length === 0) {
             return Response.sendErrorResponse(req, res, new BadDataException("fingerprint is required"));
         }
+        const primaryEntityId = readOptionalObjectIdFromBody(body, "primaryEntityId");
+        const rawPrimaryEntityType = body["primaryEntityType"];
+        let primaryEntityType = undefined;
+        if (rawPrimaryEntityType !== undefined &&
+            rawPrimaryEntityType !== null &&
+            rawPrimaryEntityType !== "") {
+            if (typeof rawPrimaryEntityType !== "string" ||
+                !Object.values(ServiceType).includes(rawPrimaryEntityType)) {
+                throw new BadDataException("primaryEntityType is not valid");
+            }
+            primaryEntityType = rawPrimaryEntityType;
+        }
+        if (primaryEntityId === undefined && primaryEntityType !== undefined) {
+            throw new BadDataException("primaryEntityId is required with its type");
+        }
         /*
          * An exception is not scoped to a RUM application, so there is no
          * single application to authorize against. Restrict the query to
@@ -3572,7 +3650,7 @@ router.post("/telemetry/rum/session-replay/for-exception", ...requireSessionRepl
         }
         /* Pin to the session the caller already knows threw, when it does. */
         const pinnedSessionId = body["sessionId"];
-        const sessions = await SessionReplayReadService.getSessionsForException(Object.assign(Object.assign(Object.assign(Object.assign({ projectId: projectId, exceptionFingerprint: fingerprint, accessibleRumApplicationIds: accessibleApplications.applicationIds }, (startTime !== undefined && { startTime })), (endTime !== undefined && { endTime })), (typeof pinnedSessionId === "string" &&
+        const sessions = await SessionReplayReadService.getSessionsForException(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ projectId: projectId, exceptionFingerprint: fingerprint }, (primaryEntityId !== undefined && { primaryEntityId })), (primaryEntityType !== undefined && { primaryEntityType })), { accessibleRumApplicationIds: accessibleApplications.applicationIds }), (startTime !== undefined && { startTime })), (endTime !== undefined && { endTime })), (typeof pinnedSessionId === "string" &&
             pinnedSessionId.length > 0 && { sessionId: pinnedSessionId })), { limit: readLimitFromBody(body, MAX_SESSION_REPLAY_FOR_EXCEPTION_LIMIT, MAX_SESSION_REPLAY_FOR_EXCEPTION_LIMIT) }));
         return Response.sendJsonObjectResponse(req, res, {
             sessions: sessions,