@oneuptime/common 11.7.2 → 11.7.4

package/Server/Services/IncidentService.ts

@@ -28,6 +28,9 @@ import ObjectID from "../../Types/ObjectID";
 import PositiveNumber from "../../Types/PositiveNumber";
 import Typeof from "../../Types/Typeof";
 import { applyIncidentSelfPrivacyFilter } from "../Utils/Incident/IncidentPrivacyFilter";
+import ProjectScopedReferenceValidator, {
+  resolveReferenceId,
+} from "../Utils/Database/ProjectScopedReferenceValidator";
 import UserNotificationEventType from "../../Types/UserNotification/UserNotificationEventType";
 import StatusPageSubscriberNotificationStatus from "../../Types/StatusPage/StatusPageSubscriberNotificationStatus";
 import DockerHost from "../../Models/DatabaseModels/DockerHost";
@@ -442,6 +445,8 @@ export class Service extends DatabaseService<Model> {
       updateBy.data.isVisibleOnStatusPage = false;
     }
 
+    await this.validateProjectScopedReferences(updateBy);
+
     const carryForward: UpdateCarryForward = {};
 
     if (
@@ -552,6 +557,90 @@ export class Service extends DatabaseService<Model> {
     };
   }
 
+  /*
+   * An update can repoint an incident at another project's state, severity 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 incidentStateId: ObjectID | string | undefined =
+      resolveReferenceId(updateBy.data.currentIncidentStateId) ||
+      resolveReferenceId(updateBy.data.currentIncidentState);
+
+    const incidentSeverityId: ObjectID | string | undefined =
+      resolveReferenceId(updateBy.data.incidentSeverityId) ||
+      resolveReferenceId(updateBy.data.incidentSeverity);
+
+    const changeMonitorStatusToId: ObjectID | string | undefined =
+      resolveReferenceId(updateBy.data.changeMonitorStatusToId) ||
+      resolveReferenceId(updateBy.data.changeMonitorStatusTo);
+
+    if (!incidentStateId && !incidentSeverityId && !changeMonitorStatusToId) {
+      return;
+    }
+
+    /*
+     * Root/API updates do not always carry a tenantId, so fall back to the
+     * project of each incident 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: "incident",
+        references: [
+          {
+            modelName: "Incident State",
+            id: incidentStateId,
+            service: IncidentStateService,
+          },
+          {
+            modelName: "Incident Severity",
+            id: incidentSeverityId,
+            service: IncidentSeverityService,
+          },
+          {
+            modelName: "Monitor Status",
+            id: changeMonitorStatusToId,
+            service: MonitorStatusService,
+          },
+        ],
+      });
+    }
+  }
+
+  private async getProjectIdsForUpdateQuery(
+    updateBy: UpdateBy<Model>,
+  ): Promise<Array<ObjectID>> {
+    const incidents: 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 incident of incidents) {
+      if (incident.projectId) {
+        projectIds[incident.projectId.toString()] = incident.projectId;
+      }
+    }
+
+    return Object.values(projectIds);
+  }
+
   @CaptureSpan()
   protected override async onBeforeCreate(
     createBy: CreateBy<Model>,
@@ -832,6 +921,40 @@ export class Service extends DatabaseService<Model> {
       initialIncidentStateId = incidentState.id;
     }
 
+    /*
+     * The severity and the monitor status to switch to can arrive from an API
+     * caller, an incident template or a monitor criteria, and none of those
+     * paths checked that the record belongs to this project. Persisting
+     * another project's id leaves that project undeletable, so reject it here.
+     * Runs before the counter increment so a rejected create does not burn an
+     * incident number.
+     */
+    await ProjectScopedReferenceValidator.validateReferencesBelongToProject({
+      projectId: projectId,
+      subject: "incident",
+      references: [
+        {
+          modelName: "Incident State",
+          id: initialIncidentStateId,
+          service: IncidentStateService,
+        },
+        {
+          modelName: "Incident Severity",
+          id:
+            resolveReferenceId(createBy.data.incidentSeverityId) ||
+            resolveReferenceId(createBy.data.incidentSeverity),
+          service: IncidentSeverityService,
+        },
+        {
+          modelName: "Monitor Status",
+          id:
+            resolveReferenceId(createBy.data.changeMonitorStatusToId) ||
+            resolveReferenceId(createBy.data.changeMonitorStatusTo),
+          service: MonitorStatusService,
+        },
+      ],
+    });
+
     const incidentCounterResult: {
       counter: number;
       prefix: string | undefined;

package/Server/Services/IncidentTemplateService.ts

@@ -1,20 +1,142 @@
-import { OnCreate } from "../Types/Database/Hooks";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import CreateBy from "../Types/Database/CreateBy";
+import UpdateBy from "../Types/Database/UpdateBy";
 import DatabaseService from "./DatabaseService";
 import IncidentTemplateOwnerTeamService from "./IncidentTemplateOwnerTeamService";
 import IncidentTemplateOwnerUserService from "./IncidentTemplateOwnerUserService";
+import IncidentSeverityService from "./IncidentSeverityService";
+import IncidentStateService from "./IncidentStateService";
+import MonitorStatusService from "./MonitorStatusService";
 import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import Dictionary from "../../Types/Dictionary";
 import ObjectID from "../../Types/ObjectID";
 import Typeof from "../../Types/Typeof";
 import Model from "../../Models/DatabaseModels/IncidentTemplate";
 import IncidentTemplateOwnerTeam from "../../Models/DatabaseModels/IncidentTemplateOwnerTeam";
 import IncidentTemplateOwnerUser from "../../Models/DatabaseModels/IncidentTemplateOwnerUser";
+import ProjectScopedReferenceValidator, {
+  ProjectScopedReference,
+  resolveReferenceId,
+} from "../Utils/Database/ProjectScopedReferenceValidator";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import QueryDeepPartialEntity from "../../Types/Database/PartialEntity";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
 
+  /*
+   * A template is copied onto every incident created from it, so an id
+   * belonging to another project here becomes a cross-project reference on
+   * each of those incidents — and the referenced project can then no longer be
+   * deleted. Reject it where it enters instead.
+   */
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    const projectId: ObjectID | undefined =
+      createBy.props.tenantId || createBy.data.projectId;
+
+    await ProjectScopedReferenceValidator.validateReferencesBelongToProject({
+      projectId: projectId,
+      subject: "incident template",
+      references: this.getProjectScopedReferences(createBy.data),
+    });
+
+    return { createBy, carryForward: null };
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    const references: Array<ProjectScopedReference> =
+      this.getProjectScopedReferences(updateBy.data);
+
+    if (
+      references.every((reference: ProjectScopedReference) => {
+        return !reference.id;
+      })
+    ) {
+      return { updateBy, carryForward: null };
+    }
+
+    /*
+     * 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: "incident template",
+        references: references,
+      });
+    }
+
+    return { updateBy, carryForward: null };
+  }
+
+  private getProjectScopedReferences(
+    data: Model | QueryDeepPartialEntity<Model>,
+  ): Array<ProjectScopedReference> {
+    return [
+      {
+        modelName: "Incident State",
+        id:
+          resolveReferenceId(data.initialIncidentStateId) ||
+          resolveReferenceId(data.initialIncidentState),
+        service: IncidentStateService,
+      },
+      {
+        modelName: "Incident Severity",
+        id:
+          resolveReferenceId(data.incidentSeverityId) ||
+          resolveReferenceId(data.incidentSeverity),
+        service: IncidentSeverityService,
+      },
+      {
+        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/Index.ts

@@ -134,6 +134,7 @@ import EnterpriseLicenseService from "./EnterpriseLicenseService";
 import EnterpriseLicenseInstanceService from "./EnterpriseLicenseInstanceService";
 import MarketingConversionService from "./MarketingConversionService";
 import OpenSourceDeploymentService from "./OpenSourceDeploymentService";
+import RecommendationDismissalService from "./RecommendationDismissalService";
 import ResellerPlanService from "./ResellerPlanService";
 import ResellerService from "./ResellerService";
 import ScheduledMaintenanceCustomFieldService from "./ScheduledMaintenanceCustomFieldService";
@@ -286,6 +287,7 @@ const services: Array<BaseService> = [
 
   ResellerService,
   ResellerPlanService,
+  RecommendationDismissalService,
   // Import all services in current folder here.
   AccessTokenService,
   ApiKeyPermissionService,

package/Server/Services/LogDropFilterService.ts

@@ -1,10 +1,143 @@
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/LogDropFilter";
+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: "logs",
+};
 
 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
+   * log records 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/Services/MonitorProbeService.ts

@@ -1,6 +1,7 @@
 import ObjectID from "../../Types/ObjectID";
 import CreateBy from "../Types/Database/CreateBy";
-import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import DeleteBy from "../Types/Database/DeleteBy";
+import { OnCreate, OnDelete, OnUpdate } from "../Types/Database/Hooks";
 import DatabaseService, { EntityManager } from "./DatabaseService";
 import OneUptimeDate from "../../Types/Date";
 import BadDataException from "../../Types/Exception/BadDataException";
@@ -9,6 +10,7 @@ import Monitor from "../../Models/DatabaseModels/Monitor";
 import QueryHelper from "../Types/Database/QueryHelper";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import MonitorService from "./MonitorService";
+import ProbeService from "./ProbeService";
 import { MonitorTypeHelper } from "../../Types/Monitor/MonitorType";
 import CronTab from "../Utils/CronTab";
 import logger, { LogAttributes } from "../Utils/Logger";
@@ -270,6 +272,31 @@ export class Service extends DatabaseService<MonitorProbe> {
       }
     }
 
+    /*
+     * The probe id on a create comes straight from the browser (the
+     * Monitor > Probes table posts it), so it has to be checked against the
+     * tenant exactly like the monitor-create path does - otherwise another
+     * project's probe can be attached to this monitor.
+     */
+    const probeId: ObjectID | undefined | null =
+      createBy.data.probeId || createBy.data.probe?.id;
+    const projectId: ObjectID | undefined | null =
+      createBy.data.projectId || createBy.data.project?.id;
+
+    if (probeId && projectId) {
+      const isProbeAttachable: boolean =
+        await ProbeService.isProbeAttachableToProject({
+          probeId: probeId,
+          projectId: projectId,
+        });
+
+      if (!isProbeAttachable) {
+        throw new BadDataException(
+          "Probe not found or it does not belong to this project.",
+        );
+      }
+    }
+
     // Check if the monitor type supports probes
     const monitorId: ObjectID | undefined | null =
       createBy.data.monitorId || createBy.data.monitor?.id;
@@ -362,12 +389,75 @@ export class Service extends DatabaseService<MonitorProbe> {
     return onUpdate;
   }
 
+  /*
+   * Removing a probe from a monitor changes the same aggregate that adding one
+   * or toggling isEnabled changes - Monitor.isNoProbeEnabledOnThisMonitor and
+   * isAllProbesDisconnectedFromThisMonitor. Without these hooks, deleting the
+   * last probe left the monitor claiming it was still being watched: no
+   * "Probes Not Enabled" banner and no owner notification, even though nothing
+   * was monitoring it any more.
+   *
+   * The monitorIds have to be read before the delete, because after it the
+   * rows are gone.
+   */
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<MonitorProbe>,
+  ): Promise<OnDelete<MonitorProbe>> {
+    const itemsToDelete: Array<MonitorProbe> = await this.findBy({
+      query: deleteBy.query,
+      limit: deleteBy.limit,
+      skip: deleteBy.skip,
+      select: {
+        monitorId: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return {
+      deleteBy,
+      carryForward: {
+        monitorIds: itemsToDelete
+          .map((item: MonitorProbe) => {
+            return item.monitorId;
+          })
+          .filter((monitorId: ObjectID | undefined) => {
+            return Boolean(monitorId);
+          }) as Array<ObjectID>,
+      },
+    };
+  }
+
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<MonitorProbe>,
+    _itemIdsBeforeDelete: Array<ObjectID>,
+  ): Promise<OnDelete<MonitorProbe>> {
+    const monitorIds: Array<ObjectID> =
+      (onDelete.carryForward?.monitorIds as Array<ObjectID>) || [];
+
+    const refreshedMonitorIds: Set<string> = new Set();
+
+    for (const monitorId of monitorIds) {
+      // A bulk delete can touch the same monitor many times over.
+      if (refreshedMonitorIds.has(monitorId.toString())) {
+        continue;
+      }
+
+      refreshedMonitorIds.add(monitorId.toString());
+
+      await this.refreshMonitorStatusSafely(monitorId);
+    }
+
+    return onDelete;
+  }
+
   /*
    * Refresh a single monitor's aggregate probe status without letting a
    * failure bubble up. These refreshes run in post-commit hooks
-   * (onCreateSuccess / onUpdateSuccess) after the MonitorProbe row is already
-   * persisted, so a status-refresh error must not turn a successful save into
-   * a 500 for the user — log it instead.
+   * (onCreateSuccess / onUpdateSuccess / onDeleteSuccess) after the
+   * MonitorProbe row is already persisted, so a status-refresh error must not
+   * turn a successful save into a 500 for the user — log it instead.
    */
   private async refreshMonitorStatusSafely(monitorId: ObjectID): Promise<void> {
     try {