@oneuptime/common 12.0.5 → 12.0.7

package/Server/Services/IncidentService.ts

@@ -56,6 +56,7 @@ import { MetricPointType } from "../../Models/AnalyticsModels/Metric";
 import ServiceType from "../../Types/Telemetry/ServiceType";
 import OneUptimeDate from "../../Types/Date";
 import TelemetryUtil from "../Utils/Telemetry/Telemetry";
+import MetricResourceAttributeUtil from "../../Utils/Metrics/MetricResourceAttributeUtil";
 import logger, { LogAttributes } from "../Utils/Logger";
 import ProductAnalytics from "../Utils/ProductAnalytics";
 import Semaphore, { SemaphoreMutex } from "../Infrastructure/Semaphore";
@@ -2063,6 +2064,18 @@ ${incident.remediationNotes || "No remediation notes provided."}
 
             // only emit if the incident has been resolved
             if (resolvedTimeline && resolvedTimeline.startsAt) {
+              /*
+               * Same dimension set as every other incident metric — including
+               * oneuptime.label.* / oneuptime.customField.* — so a dashboard
+               * grouped by a label does not silently lose this series.
+               */
+              const {
+                baseMetricAttributes,
+              }: { baseMetricAttributes: JSONObject } =
+                await this.getIncidentMetricContext({
+                  incidentId: incidentId,
+                });
+
               const postmortemMetric: MutableMetric = new MutableMetric();
               postmortemMetric.projectId = projectId;
               postmortemMetric.primaryEntityId = incidentId;
@@ -2076,6 +2089,7 @@ ${incident.remediationNotes || "No remediation notes provided."}
                 resolvedTimeline.startsAt,
               );
               postmortemMetric.attributes = {
+                ...baseMetricAttributes,
                 incidentId: incidentId.toString(),
                 projectId: projectId.toString(),
               };
@@ -2356,6 +2370,18 @@ ${incidentSeverity.name}
 
             // emit severity change metric
             try {
+              /*
+               * Same dimension set as every other incident metric — including
+               * oneuptime.label.* / oneuptime.customField.* — so "severity
+               * churn by product" is answerable from the metric store.
+               */
+              const {
+                baseMetricAttributes,
+              }: { baseMetricAttributes: JSONObject } =
+                await this.getIncidentMetricContext({
+                  incidentId: incidentId,
+                });
+
               const severityChangeMetric: MutableMetric = new MutableMetric();
               severityChangeMetric.projectId = projectId;
               severityChangeMetric.primaryEntityId = incidentId;
@@ -2364,6 +2390,7 @@ ${incidentSeverity.name}
               severityChangeMetric.metricPointId = `severity-change:${ObjectID.generate().toString()}`;
               severityChangeMetric.value = 1;
               severityChangeMetric.attributes = {
+                ...baseMetricAttributes,
                 incidentId: incidentId.toString(),
                 projectId: projectId.toString(),
                 newIncidentSeverityId: incidentSeverity._id?.toString() || "",
@@ -3008,6 +3035,16 @@ ${incidentSeverity.name}
           _id: true,
           name: true,
         },
+        /*
+         * A project's own taxonomy. Both become metric attributes below so
+         * dashboards can group MTTA/MTTR by the dimensions the project
+         * actually thinks in.
+         */
+        labels: {
+          _id: true,
+          name: true,
+        },
+        customFields: true,
       },
       props: {
         isRoot: true,
@@ -3121,6 +3158,14 @@ ${incidentSeverity.name}
       ownerUserNames: ownerUserNames.join(", "),
       ownerTeamIds: ownerTeamIds.join(", "),
       ownerTeamNames: ownerTeamNames.join(", "),
+      /*
+       * oneuptime.label.* / oneuptime.customField.* — namespaced, so they can
+       * never collide with the unprefixed dimensions above.
+       */
+      ...MetricResourceAttributeUtil.getResourceAttributes({
+        labels: incident.labels,
+        customFields: incident.customFields,
+      }),
     };
 
     return { incident, baseMetricAttributes };

package/Server/Services/Index.ts

@@ -70,6 +70,7 @@ import CephClusterOwnerRuleService from "./CephClusterOwnerRuleService";
 import CephClusterOwnerTeamService from "./CephClusterOwnerTeamService";
 import CephClusterOwnerUserService from "./CephClusterOwnerUserService";
 import LlmProviderService from "./LlmProviderService";
+import DataSourceService from "./DataSourceService";
 import AuditLogService from "./AuditLogService";
 import LogService from "./LogService";
 import MailService from "./MailService";
@@ -282,10 +283,12 @@ import NetworkFlowService from "./NetworkFlowService";
 import OnCallDutyPolicyTimeLogService from "./OnCallDutyPolicyTimeLogService";
 import ProjectSCIMLogService from "./ProjectSCIMLogService";
 import StatusPageSCIMLogService from "./StatusPageSCIMLogService";
+import DeletedProjectService from "./DeletedProjectService";
 
 const services: Array<BaseService> = [
   OnCallDutyPolicyTimeLogService,
   AcmeCertificateService,
+  DeletedProjectService,
   PromoCodeService,
   EnterpriseLicenseService,
   EnterpriseLicenseInstanceService,
@@ -369,6 +372,7 @@ const services: Array<BaseService> = [
   CephClusterOwnerTeamService,
   CephClusterOwnerUserService,
   LlmProviderService,
+  DataSourceService,
 
   MailService,
   MonitorCustomFieldService,

package/Server/Services/MonitorService.ts

@@ -3,6 +3,8 @@ import {
   AllowedActiveMonitorCountInFreePlan,
   IsBillingEnabled,
 } from "../EnvironmentConfig";
+import { UpdateResult } from "typeorm";
+import { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
 import { ActiveMonitoringMeteredPlan } from "../Types/Billing/MeteredPlan/AllMeteredPlans";
 import CreateBy from "../Types/Database/CreateBy";
 import { OnCreate, OnDelete, OnUpdate } from "../Types/Database/Hooks";
@@ -462,9 +464,307 @@ export class Service extends DatabaseService<Model> {
       }
     }
 
+    if (
+      updateBy.data.dependsOnMonitors !== undefined ||
+      updateBy.data.suppressAlertsWhenParentMonitorStatuses !== undefined
+    ) {
+      /*
+       * The matched monitors' own ids (self/cycle checks) and projects
+       * (parent scoping) are needed; root/API updates do not always carry
+       * a tenantId. Validation itself is hoisted: the proposed lists are
+       * identical for every matched monitor, so existence/project checks
+       * run once per distinct project and the cycle walk runs once for
+       * all targets — not once per monitor (a bulk update could match
+       * thousands).
+       */
+      const monitorsToValidate: Array<Model> = await this.findBy({
+        query: updateBy.query,
+        select: {
+          _id: true,
+          projectId: true,
+        },
+        limit: LIMIT_MAX,
+        skip: 0,
+        props: {
+          isRoot: true,
+          ignoreHooks: true,
+        },
+      });
+
+      await this.validateDependencyConfiguration({
+        targets: monitorsToValidate.map((monitor: Model) => {
+          return {
+            monitorId: monitor.id || null,
+            projectId: updateBy.props.tenantId || monitor.projectId || null,
+          };
+        }),
+        proposedParents: updateBy.data.dependsOnMonitors,
+        proposedSuppressionStatuses:
+          updateBy.data.suppressAlertsWhenParentMonitorStatuses,
+      });
+    }
+
     return { updateBy, carryForward: null };
   }
 
+  /*
+   * Guards for the alert-dependency configuration. `undefined` means "not
+   * part of this write" and validates nothing; null or an empty array
+   * (clearing the config) is always valid. The proposed lists arrive in
+   * whatever shape the API produced — relation objects, ObjectIDs, or
+   * bare uuid strings (which DatabaseService.sanitizeCreateOrUpdate only
+   * converts to entities AFTER this hook has run) — so extraction goes
+   * through resolveReferenceId, and every id comparison is normalized to
+   * lower case because Postgres matches uuids case-insensitively while
+   * ObjectID preserves the caller's casing.
+   */
+  public async validateDependencyConfiguration(input: {
+    /**
+     * The monitors this write applies to. monitorId is null on create —
+     * a new monitor cannot be part of a cycle yet.
+     */
+    targets: Array<{
+      monitorId: ObjectID | null;
+      projectId: ObjectID | null;
+    }>;
+    proposedParents: unknown;
+    proposedSuppressionStatuses: unknown;
+  }): Promise<void> {
+    const distinctProjectIds: Array<ObjectID> = [];
+    const seenProjectIds: Set<string> = new Set<string>();
+
+    for (const target of input.targets) {
+      const key: string | undefined = target.projectId
+        ?.toString()
+        .trim()
+        .toLowerCase();
+
+      if (key && !seenProjectIds.has(key)) {
+        seenProjectIds.add(key);
+        distinctProjectIds.push(target.projectId!);
+      }
+    }
+
+    if (input.proposedParents !== undefined) {
+      const parentIds: Array<ObjectID> = this.extractRelationIds(
+        input.proposedParents,
+      );
+
+      if (parentIds.length > 0) {
+        const parentIdSet: Set<string> = new Set<string>(
+          parentIds.map((id: ObjectID) => {
+            return id.toString();
+          }),
+        );
+
+        for (const target of input.targets) {
+          const targetKey: string | undefined = target.monitorId
+            ?.toString()
+            .trim()
+            .toLowerCase();
+
+          if (targetKey && parentIdSet.has(targetKey)) {
+            throw new BadDataException("A monitor cannot depend on itself.");
+          }
+        }
+
+        /*
+         * Existence + same-project via the house validator (which owns
+         * the case normalization and message wording). Once per distinct
+         * project: parents must belong to every matched monitor's
+         * project, so a cross-project bulk update correctly fails.
+         */
+        for (const projectId of distinctProjectIds) {
+          await ProjectScopedReferenceValidator.validateReferencesBelongToProject(
+            {
+              projectId: projectId,
+              subject: "monitor",
+              references: parentIds.map((parentId: ObjectID) => {
+                return {
+                  modelName: "Monitor",
+                  id: parentId,
+                  service: this,
+                };
+              }),
+            },
+          );
+        }
+
+        const targetMonitorIds: Array<ObjectID> = input.targets
+          .map((target: { monitorId: ObjectID | null }) => {
+            return target.monitorId;
+          })
+          .filter((monitorId: ObjectID | null): monitorId is ObjectID => {
+            return Boolean(monitorId);
+          });
+
+        if (targetMonitorIds.length > 0) {
+          await this.throwIfDependencyCycle({
+            targetMonitorIds,
+            proposedParentIds: parentIds,
+          });
+        }
+      }
+    }
+
+    if (input.proposedSuppressionStatuses !== undefined) {
+      const statusIds: Array<ObjectID> = this.extractRelationIds(
+        input.proposedSuppressionStatuses,
+      );
+
+      if (statusIds.length > 0) {
+        for (const projectId of distinctProjectIds) {
+          await ProjectScopedReferenceValidator.validateReferencesBelongToProject(
+            {
+              projectId: projectId,
+              subject: "monitor",
+              references: statusIds.map((statusId: ObjectID) => {
+                return {
+                  modelName: "Monitor Status",
+                  id: statusId,
+                  service: MonitorStatusService,
+                };
+              }),
+            },
+          );
+        }
+      }
+    }
+  }
+
+  /*
+   * Walk the dependency graph upward from the proposed parents; reaching
+   * any monitor being updated means the write would close a cycle, which
+   * would make suppression self-referential (A suppressed because of B,
+   * B suppressed because of A) and must be rejected. One BFS covers every
+   * target of a bulk update. The visited set bounds the walk even if a
+   * cycle already exists among ancestors, and the depth cap keeps the
+   * check cheap on degenerate graphs.
+   *
+   * This validates committed state, so two updates racing each other can
+   * still jointly commit a cycle this walk could not see; the runtime
+   * mutual-cycle guard in MonitorDependencySuppression fails open (pages
+   * instead of suppressing) if that ever happens.
+   */
+  private async throwIfDependencyCycle(input: {
+    targetMonitorIds: Array<ObjectID>;
+    proposedParentIds: Array<ObjectID>;
+  }): Promise<void> {
+    const maxDepth: number = 32;
+
+    const targetIdSet: Set<string> = new Set<string>(
+      input.targetMonitorIds.map((monitorId: ObjectID) => {
+        return monitorId.toString().trim().toLowerCase();
+      }),
+    );
+
+    const visited: Set<string> = new Set<string>();
+    let frontier: Array<ObjectID> = [...input.proposedParentIds];
+
+    for (let depth: number = 0; depth < maxDepth; depth++) {
+      if (frontier.length === 0) {
+        return;
+      }
+
+      if (
+        frontier.some((id: ObjectID) => {
+          return targetIdSet.has(id.toString().trim().toLowerCase());
+        })
+      ) {
+        throw new BadDataException(
+          "This dependency would create a cycle: one of the selected monitors (or a monitor it depends on) already depends on this monitor.",
+        );
+      }
+
+      for (const id of frontier) {
+        visited.add(id.toString().trim().toLowerCase());
+      }
+
+      const rows: Array<Model> = await this.findBy({
+        query: {
+          _id: QueryHelper.any(frontier),
+        },
+        select: {
+          _id: true,
+          dependsOnMonitors: {
+            _id: true,
+          },
+        },
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+
+      /*
+       * Fail CLOSED on truncation: a frontier level wider than the query
+       * limit means ancestors were dropped and a real cycle routed
+       * through the remainder would be admitted. Refuse instead — the
+       * sibling existence check fails closed the same way.
+       */
+      if (rows.length >= LIMIT_PER_PROJECT) {
+        throw new BadDataException(
+          "This dependency graph is too large to verify for cycles. Please reduce the number of monitors sharing one dependency level.",
+        );
+      }
+
+      const next: Array<ObjectID> = [];
+
+      for (const row of rows) {
+        for (const grandParentId of this.extractRelationIds(
+          row.dependsOnMonitors || [],
+        )) {
+          if (!visited.has(grandParentId.toString())) {
+            next.push(grandParentId);
+            visited.add(grandParentId.toString());
+          }
+        }
+      }
+
+      frontier = next;
+    }
+
+    if (frontier.length > 0) {
+      throw new BadDataException(
+        `Monitor dependency chains deeper than ${maxDepth} levels are not supported.`,
+      );
+    }
+  }
+
+  /*
+   * Ids arrive as relation objects ({_id}), ObjectIDs, or bare uuid
+   * strings depending on which API path produced the payload —
+   * resolveReferenceId handles all three (reading only ._id/.id here
+   * silently missed the bare-string shape, which DatabaseService
+   * persists). Returned ids are normalized to lower case so every
+   * comparison downstream matches the way Postgres matches uuids. null /
+   * non-array input (explicit null is TypeORM's clear-all for relation
+   * columns) yields an empty list: nothing to validate.
+   */
+  private extractRelationIds(relationArray: unknown): Array<ObjectID> {
+    if (!Array.isArray(relationArray)) {
+      return [];
+    }
+
+    const ids: Array<ObjectID> = [];
+    const seen: Set<string> = new Set<string>();
+
+    for (const item of relationArray) {
+      const rawId: string | undefined = resolveReferenceId(item)
+        ?.toString()
+        .trim()
+        .toLowerCase();
+
+      if (rawId && !seen.has(rawId)) {
+        seen.add(rawId);
+        ids.push(new ObjectID(rawId));
+      }
+    }
+
+    return ids;
+  }
+
   private async getProjectIdsForUpdateQuery(
     updateBy: UpdateBy<Model>,
   ): Promise<Array<ObjectID>> {
@@ -779,6 +1079,19 @@ export class Service extends DatabaseService<Model> {
       projectId: createBy.props.tenantId,
     });
 
+    await this.validateDependencyConfiguration({
+      // A new monitor cannot be part of a cycle yet, hence monitorId null.
+      targets: [
+        {
+          monitorId: null,
+          projectId: createBy.props.tenantId,
+        },
+      ],
+      proposedParents: createBy.data.dependsOnMonitors,
+      proposedSuppressionStatuses:
+        createBy.data.suppressAlertsWhenParentMonitorStatuses,
+    });
+
     /*
      * A new monitor starts in the project's operational status. A project can
      * hold MORE than one operational state (a user - or an E2E fixture - can
@@ -2263,5 +2576,52 @@ ${createdItem.description?.trim() || "No description provided."}
 
     return monitor.name || "";
   }
+
+  /**
+   * Repoints the currentMonitorStatusId of ALREADY SOFT-DELETED monitor rows
+   * away from monitor statuses that are about to be hard-deleted.
+   *
+   * A soft-deleted monitor keeps its physical row - and therefore its
+   * currentMonitorStatusId foreign key, which is ON DELETE NO ACTION - so a
+   * status that a since-deleted monitor last pointed at cannot be removed
+   * until that dangling reference is cleared. This surfaced as an intermittent
+   * "Monitor records still reference it" failure when Terraform destroyed a
+   * fixture that deleted its monitors and then the custom statuses those
+   * monitors had adopted.
+   *
+   * Only soft-deleted rows are touched: deleting a status that a LIVE monitor
+   * is currently in still surfaces the referential-integrity guard, so a user
+   * is never silently robbed of a monitor's visible status. Returns the number
+   * of dead rows repointed.
+   */
+  @CaptureSpan()
+  public async repointDeletedMonitorsAwayFromStatuses(data: {
+    fromMonitorStatusIds: Array<ObjectID>;
+    toMonitorStatusId: ObjectID;
+    projectId: ObjectID;
+  }): Promise<number> {
+    if (data.fromMonitorStatusIds.length === 0) {
+      return 0;
+    }
+
+    const result: UpdateResult = await this.getRepository()
+      .createQueryBuilder()
+      .update(Model)
+      .set({
+        currentMonitorStatusId: data.toMonitorStatusId.toString(),
+      } as unknown as QueryDeepPartialEntity<Model>)
+      .where('"projectId" = :projectId', {
+        projectId: data.projectId.toString(),
+      })
+      .andWhere('"deletedAt" IS NOT NULL')
+      .andWhere('"currentMonitorStatusId" IN (:...fromIds)', {
+        fromIds: data.fromMonitorStatusIds.map((id: ObjectID) => {
+          return id.toString();
+        }),
+      })
+      .execute();
+
+    return result.affected || 0;
+  }
 }
 export default new Service();

package/Server/Services/MonitorStatusService.ts

@@ -11,6 +11,14 @@ import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
 import Model from "../../Models/DatabaseModels/MonitorStatus";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+/*
+ * Statically imported despite the MonitorService <-> MonitorStatusService
+ * cycle: both modules reference each other only from method bodies (never at
+ * module-init time), so the default binding is always resolved by the time
+ * these methods run. A dynamic import() cannot be used here - the App build's
+ * TypeScript module target rejects it (TS1323).
+ */
+import MonitorService from "./MonitorService";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -51,6 +59,17 @@ export class Service extends DatabaseService<Model> {
       );
     }
 
+    /*
+     * Clear dangling currentMonitorStatusId references held by ALREADY
+     * soft-deleted monitors before the hard-delete runs. A soft-deleted
+     * monitor keeps its row and its currentMonitorStatusId foreign key
+     * (ON DELETE NO ACTION), so a status a since-deleted monitor last adopted
+     * cannot be removed while that reference lingers - the intermittent
+     * "Monitor records still reference it" failure. Live monitors are left
+     * untouched (see repointDeletedMonitorsAwayFromStatuses).
+     */
+    await this.clearDeletedMonitorReferences(deleteBy.query);
+
     let monitorStatus: Model | null = null;
 
     if (!deleteBy.props.isRoot) {
@@ -72,6 +91,153 @@ export class Service extends DatabaseService<Model> {
     };
   }
 
+  /**
+   * Repoints soft-deleted monitors that still reference the statuses matched
+   * by `query` to each project's default (lowest-priority) operational status,
+   * falling back to any other remaining status when no operational status
+   * survives. This keeps the Monitor.currentMonitorStatusId foreign key from
+   * blocking a monitor-status delete on dead rows.
+   */
+  private async clearDeletedMonitorReferences(
+    query: DeleteBy<Model>["query"],
+  ): Promise<void> {
+    const statusesBeingDeleted: Array<Model> = await this.findBy({
+      query: query,
+      select: {
+        _id: true,
+        projectId: true,
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    // Group the statuses being deleted by project.
+    const byProject: Map<
+      string,
+      { projectId: ObjectID; statusIds: Array<ObjectID> }
+    > = new Map();
+
+    for (const status of statusesBeingDeleted) {
+      if (!status.id || !status.projectId) {
+        continue;
+      }
+
+      const key: string = status.projectId.toString();
+
+      if (!byProject.has(key)) {
+        byProject.set(key, { projectId: status.projectId, statusIds: [] });
+      }
+
+      byProject.get(key)!.statusIds.push(status.id);
+    }
+
+    if (byProject.size === 0) {
+      return;
+    }
+
+    for (const { projectId, statusIds } of byProject.values()) {
+      const deletedSet: Set<string> = new Set(
+        statusIds.map((id: ObjectID) => {
+          return id.toString();
+        }),
+      );
+
+      const fallbackStatusId: ObjectID | undefined =
+        await this.findFallbackStatusId(projectId, deletedSet);
+
+      if (!fallbackStatusId) {
+        // Nothing valid to repoint to - leave the referential guard in place.
+        continue;
+      }
+
+      await MonitorService.repointDeletedMonitorsAwayFromStatuses({
+        fromMonitorStatusIds: statusIds,
+        toMonitorStatusId: fallbackStatusId,
+        projectId: projectId,
+      });
+    }
+  }
+
+  /**
+   * Picks the status a repointed monitor should fall back to: the project's
+   * default (lowest-priority) operational status that is not itself being
+   * deleted, or - if none survives - any other remaining status.
+   */
+  private async findFallbackStatusId(
+    projectId: ObjectID,
+    deletedStatusIds: Set<string>,
+  ): Promise<ObjectID | undefined> {
+    const operationalStatuses: Array<Model> = await this.findBy({
+      query: {
+        projectId: projectId,
+        isOperationalState: true,
+      },
+      select: {
+        _id: true,
+      },
+      sort: {
+        priority: SortOrder.Ascending,
+        createdAt: SortOrder.Ascending,
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    const operationalFallback: ObjectID | undefined = this.firstSurvivingId(
+      operationalStatuses,
+      deletedStatusIds,
+    );
+
+    if (operationalFallback) {
+      return operationalFallback;
+    }
+
+    // No operational status survives - repoint to any other remaining status.
+    const anyStatuses: Array<Model> = await this.findBy({
+      query: {
+        projectId: projectId,
+      },
+      select: {
+        _id: true,
+      },
+      sort: {
+        priority: SortOrder.Ascending,
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return this.firstSurvivingId(anyStatuses, deletedStatusIds);
+  }
+
+  /**
+   * Returns the id of the first status in `statuses` (already priority-sorted)
+   * that is not in `deletedStatusIds`, or undefined when none survives.
+   */
+  private firstSurvivingId(
+    statuses: Array<Model>,
+    deletedStatusIds: Set<string>,
+  ): ObjectID | undefined {
+    for (const status of statuses) {
+      const id: ObjectID | null | undefined = status.id;
+
+      if (id && !deletedStatusIds.has(id.toString())) {
+        return id;
+      }
+    }
+
+    return undefined;
+  }
+
   @CaptureSpan()
   protected override async onDeleteSuccess(
     onDelete: OnDelete<Model>,