@oneuptime/common 13.0.0 → 13.0.3

package/Server/Services/ServiceLevelObjectiveService.ts

@@ -221,9 +221,10 @@ export class Service extends DatabaseService<Model> {
     updatedItemIds: Array<ObjectID>,
   ): Promise<OnUpdate<Model>> {
     /*
-     * When an SLO is disabled, resolve its open burn-rate alerts — the
-     * evaluation worker skips disabled SLOs, so nothing else would ever
-     * resolve them (and their on-call escalations would stay open forever).
+     * When an SLO is disabled, resolve everything its burn-rate rules have
+     * open — the evaluation worker skips disabled SLOs, so nothing else
+     * would ever resolve them (and their on-call escalations would stay
+     * open forever).
      */
     if ((onUpdate.updateBy.data.isEnabled as boolean | undefined) === false) {
       for (const updatedItemId of updatedItemIds) {
@@ -242,13 +243,13 @@ export class Service extends DatabaseService<Model> {
             continue;
           }
 
-          await this.resolveOpenBurnRateAlertsForSlo({
+          await this.resolveOpenBurnRateAlertsAndIncidentsForSlo({
             sloId: updatedItemId,
             projectId: slo.projectId,
           });
         } catch (err) {
           logger.error(
-            `Error resolving open burn rate alerts for disabled SLO ${updatedItemId.toString()}: ${err}`,
+            `Error resolving open burn rate alerts and incidents for disabled SLO ${updatedItemId.toString()}: ${err}`,
           );
         }
       }
@@ -332,13 +333,13 @@ export class Service extends DatabaseService<Model> {
       }
 
       try {
-        await this.resolveOpenBurnRateAlertsForSlo({
+        await this.resolveOpenBurnRateAlertsAndIncidentsForSlo({
           sloId: item.id,
           projectId: item.projectId,
         });
       } catch (err) {
         logger.error(
-          `Error resolving open burn rate alerts for SLO ${item.id?.toString()} before delete: ${err}`,
+          `Error resolving open burn rate alerts and incidents for SLO ${item.id?.toString()} before delete: ${err}`,
           { projectId: item.projectId?.toString() } as LogAttributes,
         );
       }
@@ -353,11 +354,12 @@ export class Service extends DatabaseService<Model> {
   }
 
   /*
-   * Resolve every open Alert fired by any of this SLO's burn rate rules.
-   * Called when the SLO is disabled or deleted.
+   * Resolve everything any of this SLO's burn rate rules has left open — the
+   * Alerts they raised and the Incidents they declared. Called when the SLO is
+   * disabled or deleted, and by the worker's Misconfigured / Paused guards.
    */
   @CaptureSpan()
-  public async resolveOpenBurnRateAlertsForSlo(data: {
+  public async resolveOpenBurnRateAlertsAndIncidentsForSlo(data: {
     sloId: ObjectID;
     projectId: ObjectID;
   }): Promise<void> {
@@ -377,28 +379,68 @@ export class Service extends DatabaseService<Model> {
         },
       });
 
+    /*
+     * One rule failing must not skip the rest — but the failure must still
+     * REACH the caller. The worker's guard path (Paused / Misconfigured)
+     * deliberately resolves before it commits the new status so that a failed
+     * resolve is retried on the next tick; swallowing the error here would
+     * hand it a success, let it commit, and the next tick would see no
+     * transition and never retry, stranding the record and its on-call
+     * escalation forever. So: attempt every rule, then rethrow the first
+     * error.
+     *
+     * The lifecycle-hook callers (SLO disabled / deleted) already wrap this in
+     * their own try/catch, so propagating changes nothing for them.
+     */
+    let firstError: unknown = null;
+
     for (const rule of burnRateRules) {
       if (!rule.id) {
         continue;
       }
 
       try {
-        await ServiceLevelObjectiveBurnRateRuleService.resolveOpenAlertsForRule(
+        await ServiceLevelObjectiveBurnRateRuleService.resolveOpenAlertsAndIncidentsForRule(
           {
             serviceLevelObjectiveId: data.sloId,
             burnRateRuleId: rule.id,
             projectId: data.projectId,
             rootCause:
-              "Alert auto-resolved because the Service Level Objective was disabled or deleted.",
+              "Auto-resolved because the Service Level Objective was disabled or deleted.",
+          },
+        );
+
+        /*
+         * The rule's own lifecycle columns still say it has something open —
+         * this path deliberately does not stamp a resolve, because that would
+         * start a re-fire suppression window of up to the rule's long window.
+         * But the evaluation worker reads those same columns to decide whether
+         * an output is already open, so leaving them set silences the rule for
+         * the rest of the burn once the SLO is re-enabled. Forget the open
+         * state instead: nothing is open, and nothing just recovered.
+         */
+        await ServiceLevelObjectiveBurnRateRuleService.clearOpenOutputStateForRule(
+          {
+            burnRateRuleId: rule.id,
+            clearAlert: true,
+            clearIncident: true,
           },
         );
       } catch (err) {
         logger.error(
-          `Error resolving open alerts for burn rate rule ${rule.id?.toString()} of SLO ${data.sloId?.toString()}: ${err}`,
+          `Error resolving open alerts and incidents for burn rate rule ${rule.id?.toString()} of SLO ${data.sloId?.toString()}: ${err}`,
           { projectId: data.projectId?.toString() } as LogAttributes,
         );
+
+        if (firstError === null) {
+          firstError = err;
+        }
       }
     }
+
+    if (firstError !== null) {
+      throw firstError;
+    }
   }
 
   /*

package/Server/Services/ServiceOwnerRuleEngineService.ts

@@ -14,6 +14,7 @@ import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
 
 class ServiceOwnerRuleEngineServiceClass {
@@ -40,6 +41,7 @@ class ServiceOwnerRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             notifyOwners: true,
             serviceLabels: { _id: true },
             serviceNamePattern: true,
@@ -183,6 +185,24 @@ class ServiceOwnerRuleEngineServiceClass {
   private doesServiceMatchRule(
     service: Service,
     rule: ServiceOwnerRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: [
+        "serviceLabels",
+        "serviceNamePattern",
+        "serviceDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (serviceRule: ServiceOwnerRule): boolean => {
+        return this.doesServiceMatchRuleLegacy(service, serviceRule);
+      },
+    });
+  }
+
+  private doesServiceMatchRuleLegacy(
+    service: Service,
+    rule: ServiceOwnerRule,
   ): boolean {
     if (rule.serviceLabels && rule.serviceLabels.length > 0) {
       if (!service.labels || service.labels.length === 0) {

package/Server/Services/StatusPageLabelRuleEngineService.ts

@@ -7,6 +7,7 @@ import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
 
 class StatusPageLabelRuleEngineServiceClass {
@@ -33,6 +34,7 @@ class StatusPageLabelRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             statusPageLabels: { _id: true },
             statusPageNamePattern: true,
             statusPageDescriptionPattern: true,
@@ -143,6 +145,24 @@ class StatusPageLabelRuleEngineServiceClass {
   private doesStatusPageMatchRule(
     statusPage: StatusPage,
     rule: StatusPageLabelRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: [
+        "statusPageLabels",
+        "statusPageNamePattern",
+        "statusPageDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (statusPageRule: StatusPageLabelRule): boolean => {
+        return this.doesStatusPageMatchRuleLegacy(statusPage, statusPageRule);
+      },
+    });
+  }
+
+  private doesStatusPageMatchRuleLegacy(
+    statusPage: StatusPage,
+    rule: StatusPageLabelRule,
   ): boolean {
     if (rule.statusPageLabels && rule.statusPageLabels.length > 0) {
       if (!statusPage.labels || statusPage.labels.length === 0) {

package/Server/Services/StatusPageMonitorRuleEngineService.ts

@@ -5,6 +5,7 @@ import StatusPageResource from "../../Models/DatabaseModels/StatusPageResource";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import ObjectID from "../../Types/ObjectID";
 import UptimePrecision from "../../Types/StatusPage/UptimePrecision";
+import RuleCriteriaMatcher from "../../Utils/Rules/RuleCriteriaMatcher";
 import RulePatternMatchUtil from "../../Utils/Rules/RulePatternMatchUtil";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
@@ -71,6 +72,7 @@ const RULE_SELECT: {
   monitorLabels: { _id: true },
   monitorNamePattern: true,
   monitorDescriptionPattern: true,
+  criteria: true,
   showCurrentStatus: true,
   showUptimePercent: true,
   uptimePercentPrecision: true,
@@ -356,6 +358,27 @@ export class StatusPageMonitorRuleEngineServiceClass {
   public doesMonitorMatchRule(data: {
     monitor: Monitor;
     rule: StatusPageMonitorRule;
+  }): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: data.rule,
+      legacyFields: [
+        "monitorLabels",
+        "monitorNamePattern",
+        "monitorDescriptionPattern",
+      ],
+      emptyResult: false,
+      matchesLegacyRule: (legacyRule: StatusPageMonitorRule): boolean => {
+        return this.doesMonitorMatchLegacyRule({
+          monitor: data.monitor,
+          rule: legacyRule,
+        });
+      },
+    });
+  }
+
+  private doesMonitorMatchLegacyRule(data: {
+    monitor: Monitor;
+    rule: StatusPageMonitorRule;
   }): boolean {
     const { monitor, rule } = data;
 
@@ -436,8 +459,14 @@ export class StatusPageMonitorRuleEngineServiceClass {
     const hasDescriptionCriteria: boolean = Boolean(
       rule.monitorDescriptionPattern,
     );
+    const hasConfiguredCriteria: boolean = Boolean(rule.criteria);
 
-    if (!hasLabelCriteria && !hasNameCriteria && !hasDescriptionCriteria) {
+    if (
+      !hasConfiguredCriteria &&
+      !hasLabelCriteria &&
+      !hasNameCriteria &&
+      !hasDescriptionCriteria
+    ) {
       return [];
     }
 
@@ -448,7 +477,7 @@ export class StatusPageMonitorRuleEngineServiceClass {
       projectId: rule.projectId,
     };
 
-    if (hasLabelCriteria) {
+    if (!hasConfiguredCriteria && hasLabelCriteria) {
       query.labels = (rule.monitorLabels || [])
         .filter((label: Label) => {
           return Boolean(label.id);

package/Server/Services/StatusPageMonitorRuleService.ts

@@ -19,6 +19,10 @@ import ProjectScopedReferenceValidator, {
 } from "../Utils/Database/ProjectScopedReferenceValidator";
 import StatusPageMonitorRulePatternValidator from "../Utils/StatusPage/MonitorRulePatternValidator";
 import logger, { LogAttributes } from "../Utils/Logger";
+import {
+  getRuleCriteriaValidationError,
+  isValidRuleCriteria,
+} from "../../Utils/Rules/RuleCriteriaMatcher";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -39,6 +43,7 @@ export class Service extends DatabaseService<Model> {
       monitorLabelCount: (createBy.data.monitorLabels || []).length,
       monitorNamePattern: createBy.data.monitorNamePattern,
       monitorDescriptionPattern: createBy.data.monitorDescriptionPattern,
+      criteria: createBy.data.criteria,
     });
 
     StatusPageMonitorRulePatternValidator.validate({
@@ -356,7 +361,29 @@ export class Service extends DatabaseService<Model> {
     monitorLabelCount: number;
     monitorNamePattern?: string | undefined;
     monitorDescriptionPattern?: string | undefined;
+    criteria?: Model["criteria"];
   }): void {
+    if (data.criteria !== undefined && data.criteria !== null) {
+      const validationError: string | null = getRuleCriteriaValidationError(
+        data.criteria,
+      );
+
+      if (validationError) {
+        throw new BadDataException(validationError);
+      }
+
+      if (
+        isValidRuleCriteria(data.criteria) &&
+        data.criteria.filters.length > 0
+      ) {
+        return;
+      }
+
+      throw new BadDataException(
+        "A status page monitor rule needs at least one match condition.",
+      );
+    }
+
     if (
       data.monitorLabelCount === 0 &&
       !data.monitorNamePattern &&
@@ -400,6 +427,7 @@ export class Service extends DatabaseService<Model> {
         },
         monitorNamePattern: true,
         monitorDescriptionPattern: true,
+        criteria: true,
       },
       limit: LIMIT_PER_PROJECT,
       skip: 0,
@@ -419,7 +447,8 @@ export class Service extends DatabaseService<Model> {
     const touchesCriteria: boolean =
       updateBy.data.monitorLabels !== undefined ||
       updateBy.data.monitorNamePattern !== undefined ||
-      updateBy.data.monitorDescriptionPattern !== undefined;
+      updateBy.data.monitorDescriptionPattern !== undefined ||
+      updateBy.data.criteria !== undefined;
 
     if (!touchesCriteria) {
       return;
@@ -444,6 +473,10 @@ export class Service extends DatabaseService<Model> {
           updateBy.data.monitorDescriptionPattern === undefined
             ? rule.monitorDescriptionPattern
             : (updateBy.data.monitorDescriptionPattern as string | undefined),
+        criteria:
+          updateBy.data.criteria === undefined
+            ? rule.criteria
+            : (updateBy.data.criteria as Model["criteria"]),
       });
     }
   }

package/Server/Services/StatusPageOwnerRuleEngineService.ts

@@ -7,6 +7,7 @@ import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { MAX_RULES_EVALUATED_PER_PROJECT } from "../../Utils/Rules/RuleEngineLimits";
+import { RuleCriteriaMatcher } from "../../Utils/Rules/RuleCriteriaMatcher";
 import logIfRuleReadWasTruncated from "../Utils/Rules/RuleEngineRuleRead";
 
 class StatusPageOwnerRuleEngineServiceClass {
@@ -33,6 +34,7 @@ class StatusPageOwnerRuleEngineServiceClass {
           select: {
             _id: true,
             name: true,
+            criteria: true,
             notifyOwners: true,
             statusPageLabels: { _id: true },
             statusPageNamePattern: true,
@@ -160,6 +162,24 @@ class StatusPageOwnerRuleEngineServiceClass {
   private doesStatusPageMatchRule(
     statusPage: StatusPage,
     rule: StatusPageOwnerRule,
+  ): boolean {
+    return RuleCriteriaMatcher.matchesWithLegacySync({
+      rule: rule,
+      legacyFields: [
+        "statusPageLabels",
+        "statusPageNamePattern",
+        "statusPageDescriptionPattern",
+      ],
+      emptyResult: true,
+      matchesLegacyRule: (statusPageRule: StatusPageOwnerRule): boolean => {
+        return this.doesStatusPageMatchRuleLegacy(statusPage, statusPageRule);
+      },
+    });
+  }
+
+  private doesStatusPageMatchRuleLegacy(
+    statusPage: StatusPage,
+    rule: StatusPageOwnerRule,
   ): boolean {
     if (rule.statusPageLabels && rule.statusPageLabels.length > 0) {
       if (!statusPage.labels || statusPage.labels.length === 0) {

package/Server/Services/TeamMemberService.ts

@@ -1,5 +1,6 @@
 import DatabaseConfig from "../DatabaseConfig";
 import { IsBillingEnabled } from "../EnvironmentConfig";
+import Semaphore, { SemaphoreMutex } from "../Infrastructure/Semaphore";
 import CreateBy from "../Types/Database/CreateBy";
 import DeleteBy from "../Types/Database/DeleteBy";
 import { OnCreate, OnDelete, OnUpdate } from "../Types/Database/Hooks";
@@ -174,18 +175,26 @@ export class TeamMemberService extends DatabaseService<TeamMember> {
         id: createBy.data.projectId!,
         select: {
           seatLimit: true,
-          paymentProviderSubscriptionSeats: true,
         },
         props: {
           isRoot: true,
         },
       });
 
+      /*
+       * Billing can lag after a provider outage. Admission limits must use
+       * persisted memberships, including pending invitations.
+       */
+      const numberOfMembers: number =
+        project &&
+        (project.seatLimit || createBy.props.currentPlan === PlanType.Free)
+          ? await this.getUniqueTeamMemberCountInProject(projectId)
+          : 0;
+
       if (
         project &&
         project.seatLimit &&
-        project.paymentProviderSubscriptionSeats &&
-        project.paymentProviderSubscriptionSeats >= project.seatLimit
+        numberOfMembers >= project.seatLimit
       ) {
         throw new BadDataException(Errors.TeamMemberService.LIMIT_REACHED);
       }
@@ -193,8 +202,7 @@ export class TeamMemberService extends DatabaseService<TeamMember> {
       if (
         createBy.props.currentPlan === PlanType.Free &&
         project &&
-        project.paymentProviderSubscriptionSeats &&
-        project.paymentProviderSubscriptionSeats >= 1
+        numberOfMembers >= 1
       ) {
         throw new BadDataException(
           Errors.TeamMemberService.LIMIT_REACHED_FOR_FREE_PLAN,
@@ -535,7 +543,7 @@ export class TeamMemberService extends DatabaseService<TeamMember> {
       onCreate.createBy.data.projectId!,
     );
 
-    await this.updateSubscriptionSeatsByUniqueTeamMembersInProject(
+    await this.syncSubscriptionSeatsAfterMembershipChange(
       onCreate.createBy.data.projectId!,
     );
 
@@ -726,9 +734,7 @@ export class TeamMemberService extends DatabaseService<TeamMember> {
 
     for (const item of onDelete.carryForward as Array<TeamMember>) {
       await this.refreshTokens(item.userId!, item.projectId!);
-      await this.updateSubscriptionSeatsByUniqueTeamMembersInProject(
-        item.projectId!,
-      );
+      await this.syncSubscriptionSeatsAfterMembershipChange(item.projectId!);
 
       /*
        * Before the notification settings go: the "removed from on-call
@@ -1269,6 +1275,27 @@ export class TeamMemberService extends DatabaseService<TeamMember> {
     });
   }
 
+  /**
+   * The membership write has already committed. A payment-provider outage
+   * must not report a failed invite or prevent removal cleanup. The scheduled
+   * seat reconciliation retries projects whose acknowledged count is stale.
+   */
+  @CaptureSpan()
+  private async syncSubscriptionSeatsAfterMembershipChange(
+    projectId: ObjectID,
+  ): Promise<void> {
+    try {
+      await this.updateSubscriptionSeatsByUniqueTeamMembersInProject(projectId);
+    } catch (err) {
+      logger.error(
+        err as Error,
+        {
+          projectId: projectId.toString(),
+        } as LogAttributes,
+      );
+    }
+  }
+
   @CaptureSpan()
   public async updateSubscriptionSeatsByUniqueTeamMembersInProject(
     projectId: ObjectID,
@@ -1277,47 +1304,80 @@ export class TeamMemberService extends DatabaseService<TeamMember> {
       return;
     }
 
-    const numberOfMembers: number =
-      await this.getUniqueTeamMemberCountInProject(projectId);
-    const project: Project | null = await ProjectService.findOneById({
-      id: projectId,
-      select: {
-        paymentProviderSubscriptionId: true,
-        paymentProviderPlanId: true,
-      },
-      props: {
-        isRoot: true,
-      },
+    /*
+     * Serialize the request and worker paths, then read the latest count so
+     * an older synchronization cannot overwrite a newer seat quantity.
+     */
+    const mutex: SemaphoreMutex = await Semaphore.lock({
+      key: projectId.toString(),
+      namespace: "team-member-subscription-seats",
+      lockTimeout: 60000,
+      acquireTimeout: 5000,
     });
 
-    if (
-      project &&
-      project.paymentProviderSubscriptionId &&
-      project?.paymentProviderPlanId
-    ) {
+    try {
+      const project: Project | null = await ProjectService.findOneById({
+        id: projectId,
+        select: {
+          paymentProviderSubscriptionId: true,
+          paymentProviderPlanId: true,
+          paymentProviderSubscriptionSeats: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (
+        !project?.paymentProviderSubscriptionId ||
+        !project.paymentProviderPlanId
+      ) {
+        return;
+      }
+
       const plan: SubscriptionPlan | undefined =
-        SubscriptionPlan.getSubscriptionPlanById(
-          project?.paymentProviderPlanId,
-        );
+        SubscriptionPlan.getSubscriptionPlanById(project.paymentProviderPlanId);
 
       if (!plan) {
         return;
       }
 
+      const numberOfMembers: number =
+        await this.getUniqueTeamMemberCountInProject(projectId);
+
+      if (project.paymentProviderSubscriptionSeats === numberOfMembers) {
+        return;
+      }
+
+      /*
+       * The provider may apply the quantity and then time out. Persist that
+       * uncertainty before calling it, so even a later return to the previous
+       * member count cannot make reconciliation mistake the seats for synced.
+       */
+      const invalidated: number = await ProjectService.updateSubscriptionSeats({
+        projectId: projectId,
+        subscriptionId: project.paymentProviderSubscriptionId,
+        planId: project.paymentProviderPlanId,
+        seats: null,
+      });
+
+      if (invalidated === 0) {
+        return;
+      }
+
       await BillingService.changeQuantity(
         project.paymentProviderSubscriptionId,
         numberOfMembers,
       );
 
-      await ProjectService.updateOneById({
-        id: projectId,
-        data: {
-          paymentProviderSubscriptionSeats: numberOfMembers,
-        },
-        props: {
-          isRoot: true,
-        },
+      await ProjectService.updateSubscriptionSeats({
+        projectId: projectId,
+        subscriptionId: project.paymentProviderSubscriptionId,
+        planId: project.paymentProviderPlanId,
+        seats: numberOfMembers,
       });
+    } finally {
+      await Semaphore.release(mutex);
     }
   }