@oneuptime/common 11.7.2 → 11.7.4

package/Server/Services/ScheduledMaintenanceService.ts

@@ -24,6 +24,10 @@ import Model from "../../Models/DatabaseModels/ScheduledMaintenance";
 import ScheduledMaintenanceOwnerTeam from "../../Models/DatabaseModels/ScheduledMaintenanceOwnerTeam";
 import ScheduledMaintenanceOwnerUser from "../../Models/DatabaseModels/ScheduledMaintenanceOwnerUser";
 import ScheduledMaintenanceState from "../../Models/DatabaseModels/ScheduledMaintenanceState";
+import MonitorStatusService from "./MonitorStatusService";
+import ProjectScopedReferenceValidator, {
+  resolveReferenceId,
+} from "../Utils/Database/ProjectScopedReferenceValidator";
 import ScheduledMaintenanceStateTimeline from "../../Models/DatabaseModels/ScheduledMaintenanceStateTimeline";
 import User from "../../Models/DatabaseModels/User";
 import Recurring from "../../Types/Events/Recurring";
@@ -599,12 +603,91 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
       }
     }
 
+    await this.validateProjectScopedReferences(updateBy);
+
     return {
       updateBy,
       carryForward: null,
     };
   }
 
+  /*
+   * An update can repoint a scheduled maintenance event at another project's
+   * state or monitor status just as easily as a create can, and the result is
+   * the same: the referenced project can no longer be deleted. Only the
+   * columns actually being written are checked, so ordinary updates cost no
+   * extra queries.
+   */
+  private async validateProjectScopedReferences(
+    updateBy: UpdateBy<Model>,
+  ): Promise<void> {
+    const stateId: ObjectID | string | undefined =
+      resolveReferenceId(updateBy.data.currentScheduledMaintenanceStateId) ||
+      resolveReferenceId(updateBy.data.currentScheduledMaintenanceState);
+
+    const monitorStatusId: ObjectID | string | undefined =
+      resolveReferenceId(updateBy.data.changeMonitorStatusToId) ||
+      resolveReferenceId(updateBy.data.changeMonitorStatusTo);
+
+    if (!stateId && !monitorStatusId) {
+      return;
+    }
+
+    /*
+     * Root/API updates do not always carry a tenantId, so fall back to the
+     * project of each event the query actually matches.
+     */
+    const projectIds: Array<ObjectID> = updateBy.props.tenantId
+      ? [updateBy.props.tenantId]
+      : await this.getProjectIdsForUpdateQuery(updateBy);
+
+    for (const projectId of projectIds) {
+      await ProjectScopedReferenceValidator.validateReferencesBelongToProject({
+        projectId: projectId,
+        subject: "scheduled maintenance event",
+        references: [
+          {
+            modelName: "Scheduled Maintenance State",
+            id: stateId,
+            service: ScheduledMaintenanceStateService,
+          },
+          {
+            modelName: "Monitor Status",
+            id: monitorStatusId,
+            service: MonitorStatusService,
+          },
+        ],
+      });
+    }
+  }
+
+  private async getProjectIdsForUpdateQuery(
+    updateBy: UpdateBy<Model>,
+  ): Promise<Array<ObjectID>> {
+    const scheduledMaintenanceEvents: Array<Model> = await this.findBy({
+      query: updateBy.query,
+      select: {
+        projectId: true,
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    const projectIds: Dictionary<ObjectID> = {};
+
+    for (const scheduledMaintenance of scheduledMaintenanceEvents) {
+      if (scheduledMaintenance.projectId) {
+        projectIds[scheduledMaintenance.projectId.toString()] =
+          scheduledMaintenance.projectId;
+      }
+    }
+
+    return Object.values(projectIds);
+  }
+
   @CaptureSpan()
   protected override async onBeforeDelete(
     deleteBy: DeleteBy<Model>,
@@ -758,6 +841,26 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
     createBy.data.currentScheduledMaintenanceStateId =
       scheduledMaintenanceState.id;
 
+    /*
+     * changeMonitorStatusToId comes straight from the API caller or a
+     * template, and nothing checked it belongs to this project. Persisting
+     * another project's id leaves that project undeletable. Runs before the
+     * counter increment so a rejected create does not burn an event number.
+     */
+    await ProjectScopedReferenceValidator.validateReferencesBelongToProject({
+      projectId: projectId,
+      subject: "scheduled maintenance event",
+      references: [
+        {
+          modelName: "Monitor Status",
+          id:
+            resolveReferenceId(createBy.data.changeMonitorStatusToId) ||
+            resolveReferenceId(createBy.data.changeMonitorStatusTo),
+          service: MonitorStatusService,
+        },
+      ],
+    });
+
     const scheduledMaintenanceCounterResult: {
       counter: number;
       prefix: string | undefined;

package/Server/Services/ScheduledMaintenanceTemplateService.ts

@@ -6,6 +6,12 @@ import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCom
 import ObjectID from "../../Types/ObjectID";
 import Typeof from "../../Types/Typeof";
 import Model from "../../Models/DatabaseModels/ScheduledMaintenanceTemplate";
+import MonitorStatusService from "./MonitorStatusService";
+import Dictionary from "../../Types/Dictionary";
+import ProjectScopedReferenceValidator, {
+  ProjectScopedReference,
+  resolveReferenceId,
+} from "../Utils/Database/ProjectScopedReferenceValidator";
 import ScheduledMaintenanceTemplateOwnerTeam from "../../Models/DatabaseModels/ScheduledMaintenanceTemplateOwnerTeam";
 import ScheduledMaintenanceTemplateOwnerUser from "../../Models/DatabaseModels/ScheduledMaintenanceTemplateOwnerUser";
 import CreateBy from "../Types/Database/CreateBy";
@@ -113,6 +119,12 @@ export class Service extends DatabaseService<Model> {
   ): Promise<OnCreate<Model>> {
     this.validateEventTemplate(createBy.data);
 
+    await ProjectScopedReferenceValidator.validateReferencesBelongToProject({
+      projectId: createBy.props.tenantId || createBy.data.projectId,
+      subject: "scheduled maintenance template",
+      references: this.getProjectScopedReferences(createBy.data),
+    });
+
     if (createBy.data.isRecurringEvent) {
       // if all is good then the next scheduled at time should be set.
       createBy.data.scheduleNextEventAt = this.getNextEventTime({
@@ -253,12 +265,90 @@ export class Service extends DatabaseService<Model> {
 
     updateBy.data = newTemplate;
 
+    await this.validateProjectScopedReferences(updateBy);
+
     return {
       updateBy: updateBy,
       carryForward: false,
     };
   }
 
+  /*
+   * A template is copied onto every event created from it, so an id belonging
+   * to another project here becomes a cross-project reference on each of those
+   * events — and the referenced project can then no longer be deleted.
+   */
+  private async validateProjectScopedReferences(
+    updateBy: UpdateBy<Model>,
+  ): Promise<void> {
+    const references: Array<ProjectScopedReference> =
+      this.getProjectScopedReferences(updateBy.data);
+
+    if (
+      references.every((reference: ProjectScopedReference) => {
+        return !reference.id;
+      })
+    ) {
+      return;
+    }
+
+    /*
+     * Root/API updates do not always carry a tenantId, so fall back to the
+     * project of each template the query actually matches.
+     */
+    const projectIds: Array<ObjectID> = updateBy.props.tenantId
+      ? [updateBy.props.tenantId]
+      : await this.getProjectIdsForUpdateQuery(updateBy);
+
+    for (const projectId of projectIds) {
+      await ProjectScopedReferenceValidator.validateReferencesBelongToProject({
+        projectId: projectId,
+        subject: "scheduled maintenance template",
+        references: references,
+      });
+    }
+  }
+
+  private getProjectScopedReferences(
+    data: Model | QueryDeepPartialEntity<Model>,
+  ): Array<ProjectScopedReference> {
+    return [
+      {
+        modelName: "Monitor Status",
+        id:
+          resolveReferenceId(data.changeMonitorStatusToId) ||
+          resolveReferenceId(data.changeMonitorStatusTo),
+        service: MonitorStatusService,
+      },
+    ];
+  }
+
+  private async getProjectIdsForUpdateQuery(
+    updateBy: UpdateBy<Model>,
+  ): Promise<Array<ObjectID>> {
+    const templates: Array<Model> = await this.findBy({
+      query: updateBy.query,
+      select: {
+        projectId: true,
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    const projectIds: Dictionary<ObjectID> = {};
+
+    for (const template of templates) {
+      if (template.projectId) {
+        projectIds[template.projectId.toString()] = template.projectId;
+      }
+    }
+
+    return Object.values(projectIds);
+  }
+
   @CaptureSpan()
   protected override async onCreateSuccess(
     onCreate: OnCreate<Model>,

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/TraceDropFilterService.ts

@@ -1,10 +1,143 @@
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/TraceDropFilter";
+import CreateBy from "../Types/Database/CreateBy";
+import UpdateBy from "../Types/Database/UpdateBy";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import ObjectID from "../../Types/ObjectID";
+import OneUptimeDate from "../../Types/Date";
+import PartialEntity from "../../Types/Database/PartialEntity";
+import {
+  DropFilterCandidate,
+  DropFilterValidationOptions,
+  isSqlExpressionValue,
+  validateDropFilter,
+} from "../Utils/DropFilterValidation";
+
+const VALIDATION_OPTIONS: DropFilterValidationOptions = {
+  recordNoun: "spans",
+};
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    validateDropFilter(
+      {
+        action: createBy.data.action,
+        samplePercentage: createBy.data.samplePercentage,
+        filterQuery: createBy.data.filterQuery as string | undefined,
+      },
+      VALIDATION_OPTIONS,
+    );
+
+    return { createBy, carryForward: null };
+  }
+
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    /*
+     * An update can make a row invalid without naming every field: flipping
+     * `action` to "sample" while the stored `samplePercentage` is null, or
+     * blanking `filterQuery` on a row whose action is already "drop". So
+     * validate the MERGED row, not the incoming partial.
+     *
+     * Only pay for the SELECT when the update actually touches one of the
+     * three fields that can break the row. Drop-filter edits are rare,
+     * human-driven config changes — this is not a hot path.
+     */
+    const incomingAction: unknown = updateBy.data.action;
+    const incomingSamplePercentage: unknown = updateBy.data.samplePercentage;
+    const incomingFilterQuery: unknown = updateBy.data.filterQuery;
+
+    const touchesValidatedFields: boolean =
+      incomingAction !== undefined ||
+      incomingSamplePercentage !== undefined ||
+      incomingFilterQuery !== undefined;
+
+    if (!touchesValidatedFields) {
+      return { updateBy, carryForward: null };
+    }
+
+    if (
+      isSqlExpressionValue(incomingAction) ||
+      isSqlExpressionValue(incomingSamplePercentage) ||
+      isSqlExpressionValue(incomingFilterQuery)
+    ) {
+      // Cannot evaluate a raw SQL expression here. See isSqlExpressionValue.
+      return { updateBy, carryForward: null };
+    }
+
+    const existingRows: Array<Model> = await this.findBy({
+      query: updateBy.query,
+      skip: 0,
+      limit: LIMIT_MAX,
+      select: {
+        _id: true,
+        action: true,
+        samplePercentage: true,
+        filterQuery: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    for (const existing of existingRows) {
+      const merged: DropFilterCandidate = {
+        action:
+          incomingAction !== undefined
+            ? (incomingAction as string | null)
+            : existing.action,
+        samplePercentage:
+          incomingSamplePercentage !== undefined
+            ? (incomingSamplePercentage as number | null)
+            : existing.samplePercentage,
+        filterQuery:
+          incomingFilterQuery !== undefined
+            ? (incomingFilterQuery as string | null)
+            : (existing.filterQuery as string | null),
+      };
+
+      validateDropFilter(merged, VALIDATION_OPTIONS);
+    }
+
+    return { updateBy, carryForward: null };
+  }
+
+  /*
+   * Ingest-path counter flush: add `count` drops to this filter's running
+   * total and stamp `lastDroppedAt`, in one atomic statement.
+   *
+   * Called from the telemetry ingest workers on a throttle (many dropped
+   * spans batched into one UPDATE), never once per record, and never on the
+   * request path. Runs no hooks and does not bump `version`, so it cannot
+   * conflict with a human editing the same filter in the dashboard.
+   *
+   * See App/FeatureSet/Telemetry/Utils/DropFilterDropRecorder.ts.
+   */
+  public async addToDroppedCount(data: {
+    id: ObjectID;
+    count: number;
+    lastDroppedAt?: Date | undefined;
+  }): Promise<void> {
+    if (!data.count || data.count <= 0) {
+      return;
+    }
+
+    await this.atomicAddToColumnsByIdWithoutHooks({
+      id: data.id,
+      add: { droppedCount: data.count },
+      set: {
+        lastDroppedAt: data.lastDroppedAt || OneUptimeDate.getCurrentDate(),
+      } as PartialEntity<Model>,
+    });
+  }
 }
 
 export default new Service();

package/Server/Types/Workflow/Components/API/Delete.ts

@@ -48,6 +48,18 @@ export default class ApiDelete extends ComponentCode {
         headers: args["request-headers"] as Dictionary<string>,
       });
 
+      /*
+       * On the server API resolves with an HTTPErrorResponse instead of
+       * throwing, so the catch below never sees an HTTP error - a 4xx/5xx used
+       * to take the success port.
+       */
+      if (apiResult instanceof HTTPErrorResponse) {
+        return Promise.resolve({
+          returnValues: ApiComponentUtils.getReturnValues(apiResult),
+          executePort: result.errorPort,
+        });
+      }
+
       return Promise.resolve({
         returnValues: ApiComponentUtils.getReturnValues(apiResult),
         executePort: result.successPort,

package/Server/Types/Workflow/Components/API/Get.ts

@@ -48,6 +48,18 @@ export default class ApiGet extends ComponentCode {
         headers: args["request-headers"] as Dictionary<string>,
       });
 
+      /*
+       * On the server API resolves with an HTTPErrorResponse instead of
+       * throwing, so the catch below never sees an HTTP error - a 4xx/5xx used
+       * to take the success port.
+       */
+      if (apiResult instanceof HTTPErrorResponse) {
+        return Promise.resolve({
+          returnValues: ApiComponentUtils.getReturnValues(apiResult),
+          executePort: result.errorPort,
+        });
+      }
+
       return Promise.resolve({
         returnValues: ApiComponentUtils.getReturnValues(apiResult),
         executePort: result.successPort,

package/Server/Types/Workflow/Components/API/Patch.ts

@@ -48,6 +48,18 @@ export default class ApiPut extends ComponentCode {
         headers: args["request-headers"] as Dictionary<string>,
       });
 
+      /*
+       * On the server API resolves with an HTTPErrorResponse instead of
+       * throwing, so the catch below never sees an HTTP error - a 4xx/5xx used
+       * to take the success port.
+       */
+      if (apiResult instanceof HTTPErrorResponse) {
+        return Promise.resolve({
+          returnValues: ApiComponentUtils.getReturnValues(apiResult),
+          executePort: result.errorPort,
+        });
+      }
+
       return Promise.resolve({
         returnValues: ApiComponentUtils.getReturnValues(apiResult),
         executePort: result.successPort,

package/Server/Types/Workflow/Components/API/Post.ts

@@ -81,6 +81,18 @@ export default class ApiPost extends ComponentCode {
 
       logger.debug("API Post Component is done.", workflowLogAttributes);
 
+      /*
+       * On the server API resolves with an HTTPErrorResponse instead of
+       * throwing, so the catch below never sees an HTTP error - a 4xx/5xx used
+       * to take the success port.
+       */
+      if (apiResult instanceof HTTPErrorResponse) {
+        return Promise.resolve({
+          returnValues: ApiComponentUtils.getReturnValues(apiResult),
+          executePort: result.errorPort,
+        });
+      }
+
       return Promise.resolve({
         returnValues: ApiComponentUtils.getReturnValues(apiResult),
         executePort: result.successPort,