@oneuptime/common 11.7.3 → 12.0.0

package/Server/Services/StatusPageGroupService.ts

@@ -1,6 +1,8 @@
 import CreateBy from "../Types/Database/CreateBy";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
 import DeleteBy from "../Types/Database/DeleteBy";
 import { OnCreate, OnDelete, OnUpdate } from "../Types/Database/Hooks";
+import Query from "../Types/Database/Query";
 import QueryHelper from "../Types/Database/QueryHelper";
 import UpdateBy from "../Types/Database/UpdateBy";
 import DatabaseService from "./DatabaseService";
@@ -10,6 +12,7 @@ import LIMIT_MAX from "../../Types/Database/LimitMax";
 import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
 import PositiveNumber from "../../Types/PositiveNumber";
+import StatusPageGroupTreeUtil from "../../Utils/StatusPage/GroupTree";
 import Model from "../../Models/DatabaseModels/StatusPageGroup";
 
 export class Service extends DatabaseService<Model> {
@@ -25,6 +28,14 @@ export class Service extends DatabaseService<Model> {
       throw new BadDataException("Status Page Group statusPageId is required");
     }
 
+    if (createBy.data.parentStatusPageGroupId) {
+      await this.assertParentIsValid({
+        statusPageGroupId: null,
+        parentStatusPageGroupId: createBy.data.parentStatusPageGroupId,
+        statusPageId: createBy.data.statusPageId,
+      });
+    }
+
     if (!createBy.data.order) {
       const count: PositiveNumber = await this.countBy({
         query: {
@@ -101,10 +112,185 @@ export class Service extends DatabaseService<Model> {
     };
   }
 
+  /*
+   * The hierarchy hooks run BEFORE DatabaseService applies tenant scoping to
+   * the caller's query, so reading the raw client query with props.isRoot
+   * would hand the hook rows from other projects. Re-apply the caller's tenant
+   * so validation can never look at a row outside the caller's project.
+   */
+  private scopeQueryToCallerTenant(
+    query: Query<Model>,
+    props: DatabaseCommonInteractionProps,
+  ): Query<Model> {
+    if (props.isRoot || !props.tenantId) {
+      return query;
+    }
+
+    return {
+      ...query,
+      projectId: props.tenantId,
+    };
+  }
+
+  /*
+   * A parent has to be a real group on the same status page, and the move must
+   * not build a loop (A under B under A) or nest deeper than the tree utils
+   * are willing to walk. A loop would make every rolled up number on the page
+   * meaningless and the group itself unreachable in the rendered tree.
+   */
+  private async assertParentIsValid(data: {
+    statusPageGroupId: ObjectID | null;
+    parentStatusPageGroupId: ObjectID;
+    statusPageId: ObjectID;
+  }): Promise<void> {
+    if (
+      data.statusPageGroupId &&
+      data.statusPageGroupId.toString() ===
+        data.parentStatusPageGroupId.toString()
+    ) {
+      throw new BadDataException("A group cannot be its own parent group.");
+    }
+
+    const parent: Model | null = await this.findOneById({
+      id: data.parentStatusPageGroupId,
+      select: {
+        _id: true,
+        statusPageId: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!parent) {
+      throw new BadDataException("Parent group not found.");
+    }
+
+    if (parent.statusPageId?.toString() !== data.statusPageId.toString()) {
+      throw new BadDataException(
+        "Parent group must belong to the same status page.",
+      );
+    }
+
+    const groupsOnStatusPage: Array<Model> = await this.findBy({
+      query: {
+        statusPageId: data.statusPageId,
+      },
+      select: {
+        _id: true,
+        parentStatusPageGroupId: true,
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    const ancestorsOfParent: Array<Model> =
+      StatusPageGroupTreeUtil.getAncestorGroups({
+        statusPageGroup: parent,
+        statusPageGroups: groupsOnStatusPage,
+      });
+
+    if (
+      data.statusPageGroupId &&
+      ancestorsOfParent.some((ancestor: Model) => {
+        return ancestor._id?.toString() === data.statusPageGroupId!.toString();
+      })
+    ) {
+      throw new BadDataException(
+        "This group cannot be nested under one of its own sub groups.",
+      );
+    }
+
+    /*
+     * Depth of the parent chain, plus the group being placed. A group that is
+     * moved carries its own subtree along, so the deepest descendant has to
+     * fit under the limit too.
+     */
+    const depthOfNewParent: number = ancestorsOfParent.length + 1;
+
+    let deepestDescendantOffset: number = 0;
+
+    if (data.statusPageGroupId) {
+      const group: Model | undefined = groupsOnStatusPage.find(
+        (item: Model) => {
+          return item._id?.toString() === data.statusPageGroupId!.toString();
+        },
+      );
+
+      if (group) {
+        for (const descendant of StatusPageGroupTreeUtil.getDescendantGroups({
+          statusPageGroup: group,
+          statusPageGroups: groupsOnStatusPage,
+        })) {
+          const relativeDepth: number =
+            StatusPageGroupTreeUtil.getDepth({
+              statusPageGroup: descendant,
+              statusPageGroups: groupsOnStatusPage,
+            }) -
+            StatusPageGroupTreeUtil.getDepth({
+              statusPageGroup: group,
+              statusPageGroups: groupsOnStatusPage,
+            });
+
+          deepestDescendantOffset = Math.max(
+            deepestDescendantOffset,
+            relativeDepth,
+          );
+        }
+      }
+    }
+
+    if (
+      depthOfNewParent + deepestDescendantOffset >=
+      StatusPageGroupTreeUtil.MaxNestingDepth
+    ) {
+      throw new BadDataException(
+        `Status page groups can only be nested ${StatusPageGroupTreeUtil.MaxNestingDepth} levels deep.`,
+      );
+    }
+  }
+
   @CaptureSpan()
   protected override async onBeforeUpdate(
     updateBy: UpdateBy<Model>,
   ): Promise<OnUpdate<Model>> {
+    const newParentIdValue: unknown = (updateBy.data as any)[
+      "parentStatusPageGroupId"
+    ];
+
+    // detaching a group (parent set to null) has no parent to validate.
+    if (newParentIdValue) {
+      const newParentId: ObjectID = new ObjectID(newParentIdValue.toString());
+
+      const groupsBeingUpdated: Array<Model> = await this.findBy({
+        query: this.scopeQueryToCallerTenant(updateBy.query, updateBy.props),
+        select: {
+          _id: true,
+          statusPageId: true,
+        },
+        limit: LIMIT_MAX,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+
+      for (const group of groupsBeingUpdated) {
+        if (!group.id || !group.statusPageId) {
+          continue;
+        }
+
+        await this.assertParentIsValid({
+          statusPageGroupId: group.id,
+          parentStatusPageGroupId: newParentId,
+          statusPageId: group.statusPageId,
+        });
+      }
+    }
+
     if (updateBy.data.order && !updateBy.props.isRoot && updateBy.query._id) {
       const group: Model | null = await this.findOneBy({
         query: {

package/Server/Services/StatusPageService.ts

@@ -75,23 +75,27 @@ import {
   MASTER_PASSWORD_COOKIE_IDENTIFIER,
   MASTER_PASSWORD_REQUIRED_MESSAGE,
 } from "../../Types/StatusPage/MasterPassword";
-
-export interface StatusPageReportItem {
-  resourceName: string;
-  totalIncidentCount: number;
-  uptimePercent: number;
-  uptimePercentAsString: string;
-  downtimeInHoursAndMinutes: string;
-}
-
-export interface StatusPageReport {
-  reportDates: string; // start date and end date in string. e.g. "01 July 2021 - 14 July 2021"
-  totalResources: number;
-  totalIncidents: number;
-  averageUptimePercent: string;
-  totalDowntimeInHoursAndMinutes: string;
-  resources: Array<StatusPageReportItem>;
-}
+import StatusPageGroup from "../../Models/DatabaseModels/StatusPageGroup";
+import StatusPageGroupService from "./StatusPageGroupService";
+import StatusPageGroupTreeUtil from "../../Utils/StatusPage/GroupTree";
+import StatusPageReportTreeUtil, {
+  StatusPageReportResourceEntry,
+  StatusPageReportStructure,
+} from "../../Utils/StatusPage/Report";
+import {
+  StatusPageReport,
+  StatusPageReportGroup,
+  StatusPageReportGroupMetrics,
+  StatusPageReportItem,
+  StatusPageReportRow,
+} from "../../Types/StatusPage/StatusPageReport";
+
+export {
+  StatusPageReport,
+  StatusPageReportGroup,
+  StatusPageReportItem,
+  StatusPageReportRow,
+};
 
 export class Service extends DatabaseService<StatusPage> {
   /*
@@ -1262,6 +1266,10 @@ export class Service extends DatabaseService<StatusPage> {
         averageUptimePercent: "0%",
         totalDowntimeInHoursAndMinutes: "0",
         resources: [],
+        groups: [],
+        ungroupedResources: [],
+        rows: [],
+        hasGroups: false,
       };
     }
 
@@ -1284,7 +1292,13 @@ export class Service extends DatabaseService<StatusPage> {
         endDate: endDate,
       });
 
-    const reportItems: Array<StatusPageReportItem> = [];
+    const entries: Array<StatusPageReportResourceEntry> = [];
+
+    /*
+     * Kept alongside `entries` so a group can roll up the monitors of every
+     * resource beneath it without expanding monitor groups a second time.
+     */
+    const monitorIdsByResourceIndex: Array<Array<ObjectID>> = [];
 
     for (const resource of statusPageResources) {
       // for each of these resource, calculate uptime percent.
@@ -1324,27 +1338,30 @@ export class Service extends DatabaseService<StatusPage> {
         reportWindow,
       );
 
-      const reportItem: StatusPageReportItem = {
-        resourceName: resource.displayName || "",
-        totalIncidentCount: await this.getIncidentCountByMonitorIds({
-          monitorIds: monitorIdsForThisResource,
-          historyDays: data.historyDays,
-        }),
-        uptimePercent: uptimePercent,
-        uptimePercentAsString: `${uptimePercent}%`,
-        downtimeInHoursAndMinutes:
-          OneUptimeDate.convertMinutesToDaysHoursAndMinutes(
-            Math.ceil(downtime.totalDowntimeInSeconds / 60),
-          ),
-      };
+      entries.push({
+        statusPageResource: resource,
+        reportItem: {
+          resourceName: resource.displayName || "",
+          totalIncidentCount: await this.getIncidentCountByMonitorIds({
+            monitorIds: monitorIdsForThisResource,
+            historyDays: data.historyDays,
+          }),
+          uptimePercent: uptimePercent,
+          uptimePercentAsString: `${uptimePercent}%`,
+          downtimeInHoursAndMinutes:
+            OneUptimeDate.convertMinutesToDaysHoursAndMinutes(
+              Math.ceil(downtime.totalDowntimeInSeconds / 60),
+            ),
+        },
+      });
 
-      reportItems.push(reportItem);
+      monitorIdsByResourceIndex.push(monitorIdsForThisResource);
     }
 
     const avgUptimePercent: number =
-      reportItems.reduce((acc: number, item: StatusPageReportItem) => {
-        return acc + item.uptimePercent;
-      }, 0) / reportItems.length;
+      entries.reduce((acc: number, entry: StatusPageReportResourceEntry) => {
+        return acc + entry.reportItem.uptimePercent;
+      }, 0) / entries.length;
 
     const avgUptimePercentString: string = avgUptimePercent.toFixed(2) + "%";
 
@@ -1357,12 +1374,46 @@ export class Service extends DatabaseService<StatusPage> {
       reportWindow,
     );
 
+    /*
+     * The status page arranges its resources into a tree of groups and shows a
+     * rolled up number at every level. Recipients of this email usually have no
+     * login, so the report has to carry that hierarchy too - see
+     * StatusPageReportTreeUtil.
+     */
+    const statusPageGroups: Array<StatusPageGroup> =
+      await this.getStatusPageGroups({
+        statusPageId: data.statusPageId,
+      });
+
+    const groupMetricsByGroupId: Dictionary<StatusPageReportGroupMetrics> =
+      await this.getReportGroupMetrics({
+        statusPageGroups: statusPageGroups,
+        entries: entries,
+        monitorIdsByResourceIndex: monitorIdsByResourceIndex,
+        timeline: timeline,
+        downtimeMonitorStatuses: statusPage.downtimeMonitorStatuses || [],
+        reportWindow: reportWindow,
+        historyDays: data.historyDays,
+      });
+
+    const structure: StatusPageReportStructure = StatusPageReportTreeUtil.build(
+      {
+        entries: entries,
+        statusPageGroups: statusPageGroups,
+        groupMetricsByGroupId: groupMetricsByGroupId,
+      },
+    );
+
     return {
       reportDates: startAndEndDate,
       totalResources: statusPageResources.length,
       totalIncidents: incidentCount,
       averageUptimePercent: avgUptimePercentString,
-      resources: reportItems,
+      resources: structure.resources,
+      groups: structure.groups,
+      ungroupedResources: structure.resourcesWithoutGroup,
+      rows: structure.rows,
+      hasGroups: structure.groups.length > 0,
       totalDowntimeInHoursAndMinutes:
         OneUptimeDate.convertMinutesToDaysHoursAndMinutes(
           Math.ceil(totalDowntimeInSeconds.totalDowntimeInSeconds / 60),
@@ -1370,6 +1421,159 @@ export class Service extends DatabaseService<StatusPage> {
     };
   }
 
+  /*
+   * Uptime, downtime and incidents for each group, measured over the group and
+   * every group nested under it - the same set of resources the live status page
+   * rolls a group's number over.
+   */
+  @CaptureSpan()
+  public async getReportGroupMetrics(data: {
+    statusPageGroups: Array<StatusPageGroup>;
+    entries: Array<StatusPageReportResourceEntry>;
+    monitorIdsByResourceIndex: Array<Array<ObjectID>>;
+    timeline: Array<MonitorStatusTimeline>;
+    downtimeMonitorStatuses: Array<MonitorStatus>;
+    reportWindow: UptimeWindow;
+    historyDays: number;
+  }): Promise<Dictionary<StatusPageReportGroupMetrics>> {
+    const groupMetricsByGroupId: Dictionary<StatusPageReportGroupMetrics> = {};
+    const incidentCountByMonitorSet: Dictionary<number> = {};
+
+    for (const group of data.statusPageGroups) {
+      const groupId: string | undefined = group._id?.toString();
+
+      if (!groupId) {
+        continue;
+      }
+
+      const groupIdsInSubtree: Set<string> = new Set<string>(
+        StatusPageGroupTreeUtil.getGroupAndDescendants({
+          statusPageGroup: group,
+          statusPageGroups: data.statusPageGroups,
+        }).map((groupInSubtree: StatusPageGroup) => {
+          return groupInSubtree._id?.toString() || "";
+        }),
+      );
+
+      const uptimePercentsInSubtree: Array<number> = [];
+      const monitorIdsInSubtree: Dictionary<ObjectID> = {};
+
+      data.entries.forEach(
+        (entry: StatusPageReportResourceEntry, index: number) => {
+          const resourceGroupId: string | undefined =
+            entry.statusPageResource.statusPageGroupId?.toString();
+
+          if (!resourceGroupId || !groupIdsInSubtree.has(resourceGroupId)) {
+            return;
+          }
+
+          uptimePercentsInSubtree.push(entry.reportItem.uptimePercent);
+
+          for (const monitorId of data.monitorIdsByResourceIndex[index] || []) {
+            // de-duplicated: the same monitor can back more than one resource.
+            monitorIdsInSubtree[monitorId.toString()] = monitorId;
+          }
+        },
+      );
+
+      const monitorIds: Array<ObjectID> = Object.values(monitorIdsInSubtree);
+
+      const timelineForThisGroup: Array<MonitorStatusTimeline> =
+        data.timeline.filter((item: MonitorStatusTimeline) => {
+          return Boolean(
+            item.monitorId && monitorIdsInSubtree[item.monitorId.toString()],
+          );
+        });
+
+      const downtime: {
+        totalDowntimeInSeconds: number;
+        totalSecondsInTimePeriod: number;
+      } = UptimeUtil.getTotalDowntimeInSeconds(
+        timelineForThisGroup,
+        data.downtimeMonitorStatuses,
+        data.reportWindow,
+      );
+
+      /*
+       * Averaging the resources' percentages (rather than recomputing from the
+       * merged timeline) is what the live page does, so a group in the email
+       * shows the number a reader can compare against the page.
+       */
+      const uptimePercent: number =
+        uptimePercentsInSubtree.length > 0
+          ? UptimeUtil.calculateAvgUptimePercentage({
+              uptimePercentages: uptimePercentsInSubtree,
+              precision:
+                group.uptimePercentPrecision || UptimePrecision.TWO_DECIMAL,
+            })
+          : 0;
+
+      /*
+       * A chain like Corporate -> Region -> Market -> Unit rolls up the exact
+       * same monitors at every level, so the incident count is cached by the
+       * monitor set rather than issuing one identical query per level.
+       */
+      const monitorSetKey: string = monitorIds
+        .map((monitorId: ObjectID) => {
+          return monitorId.toString();
+        })
+        .sort()
+        .join(",");
+
+      let totalIncidentCount: number | undefined =
+        incidentCountByMonitorSet[monitorSetKey];
+
+      if (totalIncidentCount === undefined) {
+        totalIncidentCount =
+          monitorIds.length > 0
+            ? await this.getIncidentCountByMonitorIds({
+                monitorIds: monitorIds,
+                historyDays: data.historyDays,
+              })
+            : 0;
+
+        incidentCountByMonitorSet[monitorSetKey] = totalIncidentCount;
+      }
+
+      groupMetricsByGroupId[groupId] = {
+        uptimePercent: uptimePercent,
+        uptimePercentAsString: `${uptimePercent}%`,
+        downtimeInHoursAndMinutes:
+          OneUptimeDate.convertMinutesToDaysHoursAndMinutes(
+            Math.ceil(downtime.totalDowntimeInSeconds / 60),
+          ),
+        totalIncidentCount: totalIncidentCount,
+      };
+    }
+
+    return groupMetricsByGroupId;
+  }
+
+  @CaptureSpan()
+  public async getStatusPageGroups(data: {
+    statusPageId: ObjectID;
+  }): Promise<Array<StatusPageGroup>> {
+    return await StatusPageGroupService.findBy({
+      query: {
+        statusPageId: data.statusPageId,
+      },
+      select: {
+        name: true,
+        order: true,
+        parentStatusPageGroupId: true,
+        uptimePercentPrecision: true,
+      },
+      sort: {
+        order: SortOrder.Ascending,
+      },
+      skip: 0,
+      limit: LIMIT_PER_PROJECT,
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
   @CaptureSpan()
   public async getIncidentCountByMonitorIds(data: {
     monitorIds: Array<ObjectID>;

package/Server/Services/StatusPageSubscriberNotificationTemplateService.ts

@@ -277,7 +277,26 @@ export class Service extends DatabaseService<Model> {
           {
             name: "report.resources",
             description:
-              "Array of per-resource rows (resourceName, uptimePercentAsString, downtimeInHoursAndMinutes, totalIncidentCount) to loop over with {{#each}}",
+              "Array of per-resource rows (resourceName, uptimePercentAsString, downtimeInHoursAndMinutes, totalIncidentCount, groupName, groupPath) to loop over with {{#each}}",
+          },
+          {
+            name: "report.hasGroups",
+            description:
+              "true when the status page organises its resources into groups",
+          },
+          {
+            name: "report.rows",
+            description:
+              "The status page's group hierarchy flattened into render order (isGroup, name, depth, indentInPixels, uptimePercentAsString, downtimeInHoursAndMinutes, totalIncidentCount, totalResources) to loop over with {{#each}}",
+          },
+          {
+            name: "report.groups",
+            description:
+              "The group hierarchy as a nested tree (groupName, groupPath, depth, uptimePercentAsString, downtimeInHoursAndMinutes, totalIncidentCount, totalResources, resources, subGroups)",
+          },
+          {
+            name: "report.ungroupedResources",
+            description: "Per-resource rows for resources that are in no group",
           },
         ];
 

package/Server/Services/TelemetryExceptionService.ts

@@ -6,7 +6,7 @@ import ObjectID from "../../Types/ObjectID";
 import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import BadDataException from "../../Types/Exception/BadDataException";
 import AIRunType from "../../Types/AI/AIRunType";
-import AIRunStatus from "../../Types/AI/AIRunStatus";
+import AIRunStatus, { AIRunStatusHelper } from "../../Types/AI/AIRunStatus";
 import CodeFixTaskType, {
   CodeFixTaskTypeHelper,
 } from "../../Types/AI/CodeFixTaskType";
@@ -433,14 +433,7 @@ export class Service extends DatabaseService<Model> {
           taskType === CodeFixTaskType.FixException
             ? QueryHelper.equalToOrNull(CodeFixTaskType.FixException)
             : taskType,
-        // Every terminal status — see AIRunStatusHelper.isTerminalStatus.
-        status: QueryHelper.notIn([
-          AIRunStatus.Completed,
-          AIRunStatus.NoFixFound,
-          AIRunStatus.Error,
-          AIRunStatus.Cancelled,
-          AIRunStatus.Stale,
-        ]),
+        status: QueryHelper.notIn(AIRunStatusHelper.terminalStatuses()),
       },
       select: {
         _id: true,
@@ -490,13 +483,7 @@ export class Service extends DatabaseService<Model> {
           data.taskType === CodeFixTaskType.FixException
             ? QueryHelper.equalToOrNull(CodeFixTaskType.FixException)
             : data.taskType,
-        status: QueryHelper.notIn([
-          AIRunStatus.Completed,
-          AIRunStatus.NoFixFound,
-          AIRunStatus.Error,
-          AIRunStatus.Cancelled,
-          AIRunStatus.Stale,
-        ]),
+        status: QueryHelper.notIn(AIRunStatusHelper.terminalStatuses()),
       },
       select: {
         triggeredByTelemetryExceptionId: true,

package/Server/Services/TelemetryUsageBillingService.ts

@@ -19,6 +19,7 @@ import LogService from "./LogService";
 import MetricService from "./MetricService";
 import ExceptionInstanceService from "./ExceptionInstanceService";
 import ProfileService from "./ProfileService";
+import RumSessionService from "./RumSessionService";
 import ProfileSampleService from "./ProfileSampleService";
 import DiskSize from "../../Types/DiskSize";
 import logger from "../Utils/Logger";
@@ -44,6 +45,7 @@ import {
   AverageMetricRowSizeInBytes,
   AverageExceptionRowSizeInBytes,
   AverageProfileRowSizeInBytes,
+  AverageSessionReplaySessionSizeInBytes,
   AverageProfileSampleRowSizeInBytes,
   IsBillingEnabled,
 } from "../EnvironmentConfig";
@@ -103,9 +105,16 @@ export class Service extends DatabaseService<Model> {
     const averageProfileSampleRowSizeInBytes: number =
       this.getAverageProfileSampleRowSize();
 
+    /*
+     * Session replay is exempt from the average-row-size precondition. The
+     * other pillars fall back to an average when byteSize(*) returns 0, but
+     * replay sums an exact payloadBytes recorded at ingest, so a zero average
+     * is not a reason to skip the day.
+     */
     if (
       data.productType !== ProductType.Traces &&
       data.productType !== ProductType.Profiles &&
+      data.productType !== ProductType.SessionReplay &&
       averageRowSizeInBytes <= 0
     ) {
       return;
@@ -226,6 +235,20 @@ export class Service extends DatabaseService<Model> {
           }),
           averageRowSizeInBytes,
         );
+      } else if (data.productType === ProductType.SessionReplay) {
+        /*
+         * One table only, and a bespoke aggregation - see
+         * RumSessionService.groupSessionReplayUsageByEntity for why metering
+         * must not touch the chunk table or use byteSize(*).
+         */
+        addUsage(
+          await RumSessionService.groupSessionReplayUsageByEntity({
+            projectId: data.projectId,
+            startDate: startOfDay,
+            endDate: endOfDay,
+          }),
+          averageRowSizeInBytes,
+        );
       } else if (data.productType === ProductType.Profiles) {
         addUsage(
           await ProfileService.groupTelemetryUsageByService({
@@ -527,7 +550,8 @@ export class Service extends DatabaseService<Model> {
       data.productType !== ProductType.Traces &&
       data.productType !== ProductType.Metrics &&
       data.productType !== ProductType.Logs &&
-      data.productType !== ProductType.Profiles
+      data.productType !== ProductType.Profiles &&
+      data.productType !== ProductType.SessionReplay
     ) {
       throw new BadDataException(
         "This product type is not a telemetry product type.",
@@ -633,7 +657,8 @@ export class Service extends DatabaseService<Model> {
       productType !== ProductType.Traces &&
       productType !== ProductType.Logs &&
       productType !== ProductType.Metrics &&
-      productType !== ProductType.Profiles
+      productType !== ProductType.Profiles &&
+      productType !== ProductType.SessionReplay
     ) {
       return fallbackSize;
     }
@@ -644,6 +669,12 @@ export class Service extends DatabaseService<Model> {
         [ProductType.Logs]: AverageLogRowSizeInBytes,
         [ProductType.Metrics]: AverageMetricRowSizeInBytes,
         [ProductType.Profiles]: AverageProfileRowSizeInBytes,
+        /*
+         * Dead code by design: replay sums an exact payloadBytes, so this
+         * fallback is only reachable if a session somehow recorded zero bytes.
+         * Present so the narrowed lookup above stays exhaustive.
+         */
+        [ProductType.SessionReplay]: AverageSessionReplaySessionSizeInBytes,
       }[productType] ?? fallbackSize;
 
     if (!Number.isFinite(value) || value <= 0) {