@oneuptime/common 10.0.73 → 10.0.78

package/Server/Services/IncidentService.ts

@@ -1932,6 +1932,41 @@ ${incidentSeverity.name}
     return incidentCount.toNumber() > 0;
   }
 
+  @CaptureSpan()
+  public async doesMonitorHaveActiveIncidents(
+    monitorId: ObjectID,
+    projectId: ObjectID,
+  ): Promise<boolean> {
+    const resolvedState: IncidentState | null =
+      await IncidentStateService.findOneBy({
+        query: {
+          projectId: projectId,
+          isResolvedState: true,
+        },
+        props: {
+          isRoot: true,
+        },
+        select: {
+          _id: true,
+          order: true,
+        },
+      });
+
+    const incidentCount: PositiveNumber = await this.countBy({
+      query: {
+        monitors: QueryHelper.inRelationArray([monitorId]),
+        currentIncidentState: {
+          order: QueryHelper.lessThan(resolvedState?.order as number),
+        },
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return incidentCount.toNumber() > 0;
+  }
+
   @CaptureSpan()
   public async markMonitorsActiveForMonitoring(
     projectId: ObjectID,
@@ -1980,6 +2015,19 @@ ${incidentSeverity.name}
             },
           });
 
+          /*
+           * Don't flip the monitor to operational while other incidents
+           * are still open on it — e.g. a metric monitor with group-by
+           * may have one incident per series, and resolving one series
+           * shouldn't claim the whole monitor is healthy.
+           */
+          const hasOtherActiveIncidents: boolean =
+            await this.doesMonitorHaveActiveIncidents(monitor.id!, projectId!);
+
+          if (hasOtherActiveIncidents) {
+            continue;
+          }
+
           const latestState: MonitorStatusTimeline | null =
             await MonitorStatusTimelineService.findOneBy({
               query: {

package/Server/Utils/Monitor/MonitorAlert.ts

@@ -16,9 +16,7 @@ import { TelemetryQuery } from "../../../Types/Telemetry/TelemetryQuery";
 import { DisableAutomaticAlertCreation } from "../../EnvironmentConfig";
 import AlertService from "../../Services/AlertService";
 import AlertSeverityService from "../../Services/AlertSeverityService";
-import AlertStateService from "../../Services/AlertStateService";
 import AlertStateTimelineService from "../../Services/AlertStateTimelineService";
-import AlertState from "../../../Models/DatabaseModels/AlertState";
 import logger, { LogAttributes } from "../Logger";
 import CaptureSpan from "../Telemetry/CaptureSpan";
 import DataToProcess from "./DataToProcess";
@@ -372,82 +370,6 @@ export default class MonitorAlert {
         input.openAlert.projectId!,
       );
 
-    /*
-     * Skip the Resolved insert if the alert's timeline is already at or past
-     * the Resolved state in the project's workflow order. Two cases:
-     *  1. Latest timeline state is Resolved but Alert.currentAlertStateId is
-     *     stuck on an earlier state (partial-failure from a prior resolve).
-     *     Re-inserting Resolved would throw "Alert state cannot be same as
-     *     previous state" from AlertStateTimelineService.onBeforeCreate.
-     *  2. The project defines a custom state after Resolved (e.g. Closed) and
-     *     the alert has moved into it. Inserting Resolved would throw
-     *     "cannot transition to Resolved from Closed because Resolved is
-     *     before Closed in the order of alert states."
-     * Either failure bubbles up through ingest workers and causes monitors to
-     * flap. Reconcile Alert.currentAlertStateId if out of sync with the
-     * timeline, then return.
-     */
-    const [resolvedState, latestTimeline]: [
-      AlertState | null,
-      AlertStateTimeline | null,
-    ] = await Promise.all([
-      AlertStateService.findOneBy({
-        query: {
-          _id: resolvedStateId.toString(),
-        },
-        select: {
-          order: true,
-        },
-        props: {
-          isRoot: true,
-        },
-      }),
-      AlertStateTimelineService.findOneBy({
-        query: {
-          alertId: input.openAlert.id!,
-        },
-        sort: {
-          startsAt: SortOrder.Descending,
-        },
-        select: {
-          alertStateId: true,
-          alertState: {
-            order: true,
-          },
-        },
-        props: {
-          isRoot: true,
-        },
-      }),
-    ]);
-
-    const latestOrder: number | undefined | null =
-      latestTimeline?.alertState?.order;
-    const resolvedOrder: number | undefined | null = resolvedState?.order;
-
-    if (
-      latestTimeline?.alertStateId &&
-      typeof latestOrder === "number" &&
-      typeof resolvedOrder === "number" &&
-      latestOrder >= resolvedOrder
-    ) {
-      if (
-        input.openAlert.currentAlertStateId?.toString() !==
-        latestTimeline.alertStateId.toString()
-      ) {
-        await AlertService.updateOneById({
-          id: input.openAlert.id!,
-          data: {
-            currentAlertStateId: latestTimeline.alertStateId,
-          },
-          props: {
-            isRoot: true,
-          },
-        });
-      }
-      return;
-    }
-
     const alertStateTimeline: AlertStateTimeline = new AlertStateTimeline();
     alertStateTimeline.alertId = input.openAlert.id!;
     alertStateTimeline.alertStateId = resolvedStateId;

package/Server/Utils/Monitor/MonitorCriteriaEvaluator.ts

@@ -78,6 +78,30 @@ export default class MonitorCriteriaEvaluator {
     }
 
     for (const criteriaInstance of criteria.data.monitorCriteriaInstanceArray) {
+      /*
+       * Record disabled criteria in the summary (so the user can see why
+       * nothing happened) but skip evaluation, status changes, incidents,
+       * and alerts.
+       */
+      if (criteriaInstance.data?.isEnabled === false) {
+        const skipReason: string =
+          "This criteria is disabled and was not evaluated.";
+        const skippedCriteriaResult: MonitorEvaluationCriteriaResult = {
+          criteriaId: criteriaInstance.data?.id,
+          criteriaName: criteriaInstance.data?.name,
+          filterCondition:
+            criteriaInstance.data?.filterCondition || FilterCondition.All,
+          met: false,
+          message: skipReason,
+          filters: [],
+          skipped: true,
+          skipReason: skipReason,
+        };
+
+        input.evaluationSummary.criteriaResults.push(skippedCriteriaResult);
+        continue;
+      }
+
       const criteriaResult: MonitorEvaluationCriteriaResult = {
         criteriaId: criteriaInstance.data?.id,
         criteriaName: criteriaInstance.data?.name,

package/Server/Utils/Monitor/MonitorIncident.ts

@@ -17,10 +17,8 @@ import { TelemetryQuery } from "../../../Types/Telemetry/TelemetryQuery";
 import { DisableAutomaticIncidentCreation } from "../../EnvironmentConfig";
 import IncidentService from "../../Services/IncidentService";
 import IncidentSeverityService from "../../Services/IncidentSeverityService";
-import IncidentStateService from "../../Services/IncidentStateService";
 import IncidentStateTimelineService from "../../Services/IncidentStateTimelineService";
 import IncidentMemberService from "../../Services/IncidentMemberService";
-import IncidentState from "../../../Models/DatabaseModels/IncidentState";
 import logger, { LogAttributes } from "../Logger";
 import CaptureSpan from "../Telemetry/CaptureSpan";
 import DataToProcess from "./DataToProcess";
@@ -468,82 +466,6 @@ export default class MonitorIncident {
         input.openIncident.projectId!,
       );
 
-    /*
-     * Skip the Resolved insert if the incident's timeline is already at or
-     * past the Resolved state in the project's workflow order. Two cases:
-     *  1. Latest timeline state is Resolved but Incident.currentIncidentStateId
-     *     is stuck on an earlier state (partial-failure from a prior resolve).
-     *     Re-inserting Resolved would throw "state cannot be same as previous"
-     *     from IncidentStateTimelineService.onBeforeCreate.
-     *  2. The project defines a custom state after Resolved (e.g. Closed) and
-     *     the incident has moved into it. Inserting Resolved would throw
-     *     "cannot transition to Resolved from Closed because Resolved is
-     *     before Closed in the order of incident states."
-     * Either failure bubbles up through ingest workers and causes monitors to
-     * flap. Reconcile Incident.currentIncidentStateId if out of sync with the
-     * timeline, then return.
-     */
-    const [resolvedState, latestTimeline]: [
-      IncidentState | null,
-      IncidentStateTimeline | null,
-    ] = await Promise.all([
-      IncidentStateService.findOneBy({
-        query: {
-          _id: resolvedStateId.toString(),
-        },
-        select: {
-          order: true,
-        },
-        props: {
-          isRoot: true,
-        },
-      }),
-      IncidentStateTimelineService.findOneBy({
-        query: {
-          incidentId: input.openIncident.id!,
-        },
-        sort: {
-          startsAt: SortOrder.Descending,
-        },
-        select: {
-          incidentStateId: true,
-          incidentState: {
-            order: true,
-          },
-        },
-        props: {
-          isRoot: true,
-        },
-      }),
-    ]);
-
-    const latestOrder: number | undefined | null =
-      latestTimeline?.incidentState?.order;
-    const resolvedOrder: number | undefined | null = resolvedState?.order;
-
-    if (
-      latestTimeline?.incidentStateId &&
-      typeof latestOrder === "number" &&
-      typeof resolvedOrder === "number" &&
-      latestOrder >= resolvedOrder
-    ) {
-      if (
-        input.openIncident.currentIncidentStateId?.toString() !==
-        latestTimeline.incidentStateId.toString()
-      ) {
-        await IncidentService.updateOneById({
-          id: input.openIncident.id!,
-          data: {
-            currentIncidentStateId: latestTimeline.incidentStateId,
-          },
-          props: {
-            isRoot: true,
-          },
-        });
-      }
-      return;
-    }
-
     const incidentStateTimeline: IncidentStateTimeline =
       new IncidentStateTimeline();
     incidentStateTimeline.incidentId = input.openIncident.id!;

package/Types/Dashboard/DashboardLanguage.ts

@@ -0,0 +1,30 @@
+export interface DashboardLanguage {
+  code: string;
+  nativeName: string;
+  englishName: string;
+}
+
+export const DEFAULT_DASHBOARD_LANGUAGE: string = "en";
+
+export const SUPPORTED_DASHBOARD_LANGUAGES: Array<DashboardLanguage> = [
+  { code: "en", nativeName: "English", englishName: "English" },
+  { code: "de", nativeName: "Deutsch", englishName: "German" },
+  { code: "fr", nativeName: "Français", englishName: "French" },
+  { code: "es", nativeName: "Español", englishName: "Spanish" },
+  { code: "it", nativeName: "Italiano", englishName: "Italian" },
+  { code: "pt", nativeName: "Português", englishName: "Portuguese" },
+  { code: "nl", nativeName: "Nederlands", englishName: "Dutch" },
+  { code: "da", nativeName: "Dansk", englishName: "Danish" },
+  { code: "no", nativeName: "Norsk", englishName: "Norwegian" },
+  { code: "sv", nativeName: "Svenska", englishName: "Swedish" },
+  { code: "ru", nativeName: "Русский", englishName: "Russian" },
+  { code: "ja", nativeName: "日本語", englishName: "Japanese" },
+  { code: "ko", nativeName: "한국어", englishName: "Korean" },
+  { code: "zh", nativeName: "中文", englishName: "Chinese" },
+  { code: "hi", nativeName: "हिन्दी", englishName: "Hindi" },
+];
+
+export const SUPPORTED_DASHBOARD_LANGUAGE_CODES: Array<string> =
+  SUPPORTED_DASHBOARD_LANGUAGES.map((language: DashboardLanguage) => {
+    return language.code;
+  });

package/Types/Icon/IconProp.ts

@@ -75,6 +75,7 @@ enum IconProp {
   Time = "Time",
   Terminal = "Terminal",
   Drag = "Drag",
+  GripVertical = "GripVertical",
   Error = "Error",
   Code = "Code",
   Report = "Report",

package/Types/Monitor/MonitorCriteriaInstance.ts

@@ -30,6 +30,7 @@ export interface MonitorCriteriaInstanceType {
   changeMonitorStatus?: boolean | undefined;
   createIncidents?: boolean | undefined;
   createAlerts?: boolean | undefined;
+  isEnabled?: boolean | undefined;
   id: string;
 }
 
@@ -52,6 +53,7 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
       createIncidents: false,
       createAlerts: false,
       changeMonitorStatus: false,
+      isEnabled: true,
       incidents: [],
       alerts: [],
       name: "",
@@ -1375,6 +1377,14 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
     return this;
   }
 
+  public setIsEnabled(isEnabled: boolean | undefined): MonitorCriteriaInstance {
+    if (this.data) {
+      this.data.isEnabled = isEnabled;
+    }
+
+    return this;
+  }
+
   public override toJSON(): JSONObject {
     if (!this.data) {
       return MonitorCriteriaInstance.getNewMonitorCriteriaInstanceAsJSON();
@@ -1392,6 +1402,7 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
         createAlerts: this.data.createAlerts,
         changeMonitorStatus: this.data.changeMonitorStatus,
         createIncidents: this.data.createIncidents,
+        isEnabled: this.data.isEnabled,
         name: this.data.name,
         description: this.data.description,
       } as any,
@@ -1499,6 +1510,8 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
       changeMonitorStatus: (json["changeMonitorStatus"] as boolean) || false,
       createIncidents: (json["createIncidents"] as boolean) || false,
       createAlerts: (json["createAlerts"] as boolean) || false,
+      isEnabled:
+        json["isEnabled"] === undefined ? true : (json["isEnabled"] as boolean),
       filters: filters as any,
       incidents: incidents as any,
       alerts: alerts as any,
@@ -1524,6 +1537,7 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
         changeMonitorStatus: Zod.boolean().optional(),
         createIncidents: Zod.boolean().optional(),
         createAlerts: Zod.boolean().optional(),
+        isEnabled: Zod.boolean().optional(),
       }).openapi({
         type: "object",
         example: {

package/Types/Monitor/MonitorEvaluationSummary.ts

@@ -28,6 +28,8 @@ export interface MonitorEvaluationCriteriaResult {
   met: boolean;
   message: string;
   filters: Array<MonitorEvaluationFilterResult>;
+  skipped?: boolean | undefined;
+  skipReason?: string | undefined;
 }
 
 export interface MonitorEvaluationEvent {

package/UI/Components/Icon/Icon.tsx

@@ -1243,6 +1243,14 @@ const Icon: FunctionComponent<ComponentProps> = ({
         d="M12 6.75a.75.75 0 110-1.5.75.75 0 010 1.5zM12 12.75a.75.75 0 110-1.5.75.75 0 010 1.5zM12 18.75a.75.75 0 110-1.5.75.75 0 010 1.5z"
       />,
     );
+  } else if (icon === IconProp.GripVertical) {
+    return getSvgWrapper(
+      <path
+        fill="currentColor"
+        stroke="none"
+        d="M9 5a1.5 1.5 0 11-3 0 1.5 1.5 0 013 0zM9 12a1.5 1.5 0 11-3 0 1.5 1.5 0 013 0zM9 19a1.5 1.5 0 11-3 0 1.5 1.5 0 013 0zM18 5a1.5 1.5 0 11-3 0 1.5 1.5 0 013 0zM18 12a1.5 1.5 0 11-3 0 1.5 1.5 0 013 0zM18 19a1.5 1.5 0 11-3 0 1.5 1.5 0 013 0z"
+      />,
+    );
   } else if (icon === IconProp.Graph) {
     return getSvgWrapper(
       <path

package/build/dist/Server/Services/IncidentService.js

@@ -1427,6 +1427,33 @@ ${incidentSeverity.name}
         });
         return incidentCount.toNumber() > 0;
     }
+    async doesMonitorHaveActiveIncidents(monitorId, projectId) {
+        const resolvedState = await IncidentStateService.findOneBy({
+            query: {
+                projectId: projectId,
+                isResolvedState: true,
+            },
+            props: {
+                isRoot: true,
+            },
+            select: {
+                _id: true,
+                order: true,
+            },
+        });
+        const incidentCount = await this.countBy({
+            query: {
+                monitors: QueryHelper.inRelationArray([monitorId]),
+                currentIncidentState: {
+                    order: QueryHelper.lessThan(resolvedState === null || resolvedState === void 0 ? void 0 : resolvedState.order),
+                },
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+        return incidentCount.toNumber() > 0;
+    }
     async markMonitorsActiveForMonitoring(projectId, monitors, startsAt) {
         // resolve all the monitors.
         var _a;
@@ -1460,6 +1487,16 @@ ${incidentSeverity.name}
                             isRoot: true,
                         },
                     });
+                    /*
+                     * Don't flip the monitor to operational while other incidents
+                     * are still open on it — e.g. a metric monitor with group-by
+                     * may have one incident per series, and resolving one series
+                     * shouldn't claim the whole monitor is healthy.
+                     */
+                    const hasOtherActiveIncidents = await this.doesMonitorHaveActiveIncidents(monitor.id, projectId);
+                    if (hasOtherActiveIncidents) {
+                        continue;
+                    }
                     const latestState = await MonitorStatusTimelineService.findOneBy({
                         query: {
                             monitorId: monitor.id,
@@ -2214,6 +2251,13 @@ __decorate([
         ObjectID]),
     __metadata("design:returntype", Promise)
 ], Service.prototype, "doesMonitorHasMoreActiveManualIncidents", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectID,
+        ObjectID]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "doesMonitorHaveActiveIncidents", null);
 __decorate([
     CaptureSpan(),
     __metadata("design:type", Function),