@oneuptime/common 10.5.2 → 10.5.4

package/Server/Infrastructure/Postgres/SchemaMigrations/1779971548393-AddLabelGroupByToGroupingRules.ts

@@ -0,0 +1,37 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddLabelGroupByToGroupingRules1779971548393
+  implements MigrationInterface
+{
+  public name: string = "AddLabelGroupByToGroupingRules1779971548393";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "IncidentGroupingRule" ADD "groupByIncidentLabels" boolean NOT NULL DEFAULT false`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentGroupingRule" ADD "groupByMonitorLabels" boolean NOT NULL DEFAULT false`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertGroupingRule" ADD "groupByAlertLabels" boolean NOT NULL DEFAULT false`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertGroupingRule" ADD "groupByMonitorLabels" boolean NOT NULL DEFAULT false`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "AlertGroupingRule" DROP COLUMN "groupByMonitorLabels"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AlertGroupingRule" DROP COLUMN "groupByAlertLabels"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentGroupingRule" DROP COLUMN "groupByMonitorLabels"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentGroupingRule" DROP COLUMN "groupByIncidentLabels"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -355,7 +355,9 @@ import { MigrationName1779790539196 } from "./1779790539196-MigrationName";
 import { ExpandOwnerRuleInheritFlags1779823516881 } from "./1779823516881-ExpandOwnerRuleInheritFlags";
 import { RenameStatusPageZhToZhCN1779827700000 } from "./1779827700000-RenameStatusPageZhToZhCN";
 import { MigrationName1779879993421 } from "./1779879993421-MigrationName";
-import { DedupeTelemetryExceptionsAndAddUniqueIndex1779900000000 } from "./1779900000000-DedupeTelemetryExceptionsAndAddUniqueIndex";
+import { MigrationName1779882573463 } from "./1779882573463-MigrationName";
+import { AddLabelGroupByToGroupingRules1779971548393 } from "./1779971548393-AddLabelGroupByToGroupingRules";
+
 export default [
   InitialMigration,
   MigrationName1717678334852,
@@ -713,6 +715,7 @@ export default [
   MigrationName1779790539196,
   ExpandOwnerRuleInheritFlags1779823516881,
   RenameStatusPageZhToZhCN1779827700000,
-  DedupeTelemetryExceptionsAndAddUniqueIndex1779900000000,
-  MigrationName1779879993421
+  MigrationName1779879993421,
+  MigrationName1779882573463,
+  AddLabelGroupByToGroupingRules1779971548393,
 ];

package/Server/Services/AlertGroupingEngineService.ts

@@ -16,6 +16,7 @@ import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import OneUptimeDate from "../../Types/Date";
 import QueryHelper from "../Types/Database/QueryHelper";
 import AlertGroupingRuleService from "./AlertGroupingRuleService";
+import AlertService from "./AlertService";
 import AlertEpisodeService from "./AlertEpisodeService";
 import AlertEpisodeMemberService from "./AlertEpisodeMemberService";
 import AlertEpisodeOwnerUserService from "./AlertEpisodeOwnerUserService";
@@ -91,6 +92,8 @@ class AlertGroupingEngineServiceClass {
             groupByMonitor: true,
             groupBySeverity: true,
             groupByAlertTitle: true,
+            groupByAlertLabels: true,
+            groupByMonitorLabels: true,
             // Time settings
             enableTimeWindow: true,
             timeWindowMinutes: true,
@@ -555,10 +558,84 @@ class AlertGroupingEngineServiceClass {
       parts.push(`title:${normalizedTitle}`);
     }
 
+    // Group by alert labels (exact set match) - only if explicitly enabled
+    if (rule.groupByAlertLabels && alert.id) {
+      const alertLabels: Array<Label> = await this.getAlertLabels(alert);
+      const sortedLabelIds: Array<string> = alertLabels
+        .map((l: Label) => {
+          return l.id?.toString() || "";
+        })
+        .filter((id: string) => {
+          return id.length > 0;
+        })
+        .sort();
+      parts.push(`alertLabels:${sortedLabelIds.join(",")}`);
+    }
+
+    // Group by monitor labels (exact set match) - only if explicitly enabled
+    if (rule.groupByMonitorLabels && alert.monitorId) {
+      const monitorLabels: Array<Label> = await this.getMonitorLabels(
+        alert.monitorId,
+      );
+      const sortedLabelIds: Array<string> = monitorLabels
+        .map((l: Label) => {
+          return l.id?.toString() || "";
+        })
+        .filter((id: string) => {
+          return id.length > 0;
+        })
+        .sort();
+      parts.push(`monitorLabels:${sortedLabelIds.join(",")}`);
+    }
+
     // If no group by options are enabled, all matching alerts go into a single episode
     return parts.join("|") || "default";
   }
 
+  @CaptureSpan()
+  private async getAlertLabels(alert: Alert): Promise<Array<Label>> {
+    // If labels are already loaded on the alert, use them
+    if (alert.labels && Array.isArray(alert.labels)) {
+      return alert.labels;
+    }
+
+    if (!alert.id) {
+      return [];
+    }
+
+    // Re-load alert with labels
+    const reloadedAlert: Alert | null = await AlertService.findOneById({
+      id: alert.id,
+      select: {
+        labels: {
+          _id: true,
+        },
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return reloadedAlert?.labels || [];
+  }
+
+  @CaptureSpan()
+  private async getMonitorLabels(monitorId: ObjectID): Promise<Array<Label>> {
+    const monitor: Monitor | null = await MonitorService.findOneById({
+      id: monitorId,
+      select: {
+        labels: {
+          _id: true,
+        },
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return monitor?.labels || [];
+  }
+
   @CaptureSpan()
   private async findMatchingActiveEpisode(
     projectId: ObjectID,
@@ -793,6 +870,12 @@ class AlertGroupingEngineServiceClass {
         if (rule.groupByAlertTitle) {
           groupByParts.push("Alert Title");
         }
+        if (rule.groupByAlertLabels) {
+          groupByParts.push("Alert Labels");
+        }
+        if (rule.groupByMonitorLabels) {
+          groupByParts.push("Monitor Labels");
+        }
 
         const groupByDescription: string =
           groupByParts.length > 0

package/Server/Services/IncidentGroupingEngineService.ts

@@ -17,6 +17,7 @@ import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import OneUptimeDate from "../../Types/Date";
 import QueryHelper from "../Types/Database/QueryHelper";
 import IncidentGroupingRuleService from "./IncidentGroupingRuleService";
+import IncidentService from "./IncidentService";
 import IncidentEpisodeService from "./IncidentEpisodeService";
 import IncidentEpisodeMemberService from "./IncidentEpisodeMemberService";
 import IncidentEpisodeOwnerUserService from "./IncidentEpisodeOwnerUserService";
@@ -93,6 +94,8 @@ class IncidentGroupingEngineServiceClass {
             groupByMonitor: true,
             groupBySeverity: true,
             groupByIncidentTitle: true,
+            groupByIncidentLabels: true,
+            groupByMonitorLabels: true,
             // Time settings
             enableTimeWindow: true,
             timeWindowMinutes: true,
@@ -613,10 +616,100 @@ class IncidentGroupingEngineServiceClass {
       parts.push(`title:${normalizedTitle}`);
     }
 
+    // Group by incident labels (exact set match) - only if explicitly enabled
+    if (rule.groupByIncidentLabels && incident.id) {
+      const incidentLabels: Array<Label> =
+        await this.getIncidentLabels(incident);
+      const sortedLabelIds: Array<string> = incidentLabels
+        .map((l: Label) => {
+          return l.id?.toString() || "";
+        })
+        .filter((id: string) => {
+          return id.length > 0;
+        })
+        .sort();
+      parts.push(`incidentLabels:${sortedLabelIds.join(",")}`);
+    }
+
+    /*
+     * Group by monitor labels (exact set match) - only if explicitly enabled
+     * Incidents can be associated with multiple monitors; we union and dedupe labels across all of them.
+     */
+    if (
+      rule.groupByMonitorLabels &&
+      incident.monitors &&
+      incident.monitors.length > 0
+    ) {
+      const monitorLabelIdSet: Set<string> = new Set<string>();
+      for (const incidentMonitor of incident.monitors) {
+        if (!incidentMonitor || !incidentMonitor.id) {
+          continue;
+        }
+        const monitorLabels: Array<Label> = await this.getMonitorLabels(
+          incidentMonitor.id,
+        );
+        for (const label of monitorLabels) {
+          const labelIdStr: string = label.id?.toString() || "";
+          if (labelIdStr.length > 0) {
+            monitorLabelIdSet.add(labelIdStr);
+          }
+        }
+      }
+      const sortedLabelIds: Array<string> =
+        Array.from(monitorLabelIdSet).sort();
+      parts.push(`monitorLabels:${sortedLabelIds.join(",")}`);
+    }
+
     // If no group by options are enabled, all matching incidents go into a single episode
     return parts.join("|") || "default";
   }
 
+  @CaptureSpan()
+  private async getIncidentLabels(incident: Incident): Promise<Array<Label>> {
+    // If labels are already loaded on the incident, use them
+    if (incident.labels && Array.isArray(incident.labels)) {
+      return incident.labels;
+    }
+
+    if (!incident.id) {
+      return [];
+    }
+
+    // Re-load incident with labels
+    const reloadedIncident: Incident | null = await IncidentService.findOneById(
+      {
+        id: incident.id,
+        select: {
+          labels: {
+            _id: true,
+          },
+        },
+        props: {
+          isRoot: true,
+        },
+      },
+    );
+
+    return reloadedIncident?.labels || [];
+  }
+
+  @CaptureSpan()
+  private async getMonitorLabels(monitorId: ObjectID): Promise<Array<Label>> {
+    const monitor: Monitor | null = await MonitorService.findOneById({
+      id: monitorId,
+      select: {
+        labels: {
+          _id: true,
+        },
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return monitor?.labels || [];
+  }
+
   @CaptureSpan()
   private async findMatchingActiveEpisode(
     projectId: ObjectID,
@@ -887,6 +980,12 @@ class IncidentGroupingEngineServiceClass {
         if (rule.groupByIncidentTitle) {
           groupByParts.push("Incident Title");
         }
+        if (rule.groupByIncidentLabels) {
+          groupByParts.push("Incident Labels");
+        }
+        if (rule.groupByMonitorLabels) {
+          groupByParts.push("Monitor Labels");
+        }
 
         const groupByDescription: string =
           groupByParts.length > 0

package/Server/Services/StatusPageService.ts

@@ -1247,11 +1247,16 @@ export class Service extends DatabaseService<StatusPage> {
           statusPageGroupId: true,
           statusPageGroup: {
             name: true,
+            viewMode: true,
+            rowAxisLabel: true,
+            columnAxisLabel: true,
           },
           monitorId: true,
           displayTooltip: true,
           displayDescription: true,
           displayName: true,
+          rowAxisValue: true,
+          columnAxisValue: true,
           monitor: {
             _id: true,
             currentMonitorStatusId: true,

package/Tests/Server/Services/AlertGroupingEngineService.test.ts

@@ -232,6 +232,34 @@ describe("AlertGroupingEngineService Models", () => {
       );
       expect(groupingKey).toContain(`title:${mockAlert.title}`);
     });
+
+    test("should produce identical label key regardless of label order (exact set match)", () => {
+      // Simulates buildGroupingKey's label-sorting logic.
+      const labelIdsA: string[] = ["lbl-c", "lbl-a", "lbl-b"];
+      const labelIdsB: string[] = ["lbl-b", "lbl-c", "lbl-a"];
+
+      const keyA: string = `alertLabels:${[...labelIdsA].sort().join(",")}`;
+      const keyB: string = `alertLabels:${[...labelIdsB].sort().join(",")}`;
+
+      expect(keyA).toBe(keyB);
+      expect(keyA).toBe("alertLabels:lbl-a,lbl-b,lbl-c");
+    });
+
+    test("should produce different label keys for different label sets (exact set match)", () => {
+      // Alerts with [A,B] and [A,C] must NOT group together under exact set match.
+      const keyAB: string = `alertLabels:${["lbl-a", "lbl-b"].sort().join(",")}`;
+      const keyAC: string = `alertLabels:${["lbl-a", "lbl-c"].sort().join(",")}`;
+
+      expect(keyAB).not.toBe(keyAC);
+    });
+
+    test("should emit empty label key when alert has no labels", () => {
+      // Alerts with no labels should produce the same (empty) label key.
+      const labelIds: string[] = [];
+      const key: string = `alertLabels:${[...labelIds].sort().join(",")}`;
+
+      expect(key).toBe("alertLabels:");
+    });
   });
 
   describe("Time Window Configuration", () => {

package/Tests/Server/Services/AlertGroupingRuleService.test.ts

@@ -143,14 +143,28 @@ describe("AlertGroupingRule Model", () => {
       expect(rule.groupByAlertTitle).toBe(true);
     });
 
+    test("should set and get groupByAlertLabels correctly", () => {
+      rule.groupByAlertLabels = true;
+      expect(rule.groupByAlertLabels).toBe(true);
+    });
+
+    test("should set and get groupByMonitorLabels correctly", () => {
+      rule.groupByMonitorLabels = true;
+      expect(rule.groupByMonitorLabels).toBe(true);
+    });
+
     test("should handle all groupBy options as false", () => {
       rule.groupByMonitor = false;
       rule.groupBySeverity = false;
       rule.groupByAlertTitle = false;
+      rule.groupByAlertLabels = false;
+      rule.groupByMonitorLabels = false;
 
       expect(rule.groupByMonitor).toBe(false);
       expect(rule.groupBySeverity).toBe(false);
       expect(rule.groupByAlertTitle).toBe(false);
+      expect(rule.groupByAlertLabels).toBe(false);
+      expect(rule.groupByMonitorLabels).toBe(false);
     });
 
     test("should handle combination of groupBy options", () => {

package/Types/Monitor/MonitorStep.ts

@@ -52,6 +52,39 @@ import MonitorStepDockerMonitor, {
 } from "./MonitorStepDockerMonitor";
 import Zod, { ZodSchema } from "../../Utils/Schema/Zod";
 
+/*
+ * Caps and defaults for per-step request timeout and retry settings.
+ * Users may lower these via the UI; values higher than the cap are clamped.
+ */
+export const MAX_MONITOR_REQUEST_TIMEOUT_IN_MS: number = 60000; // 60 seconds
+export const DEFAULT_MONITOR_REQUEST_TIMEOUT_IN_MS: number = 60000;
+export const MAX_MONITOR_RETRY_COUNT: number = 3;
+export const DEFAULT_MONITOR_RETRY_COUNT: number = 3;
+
+export const clampMonitorRequestTimeoutInMs: (value: number) => number = (
+  value: number,
+): number => {
+  if (!value || value <= 0) {
+    return DEFAULT_MONITOR_REQUEST_TIMEOUT_IN_MS;
+  }
+  if (value > MAX_MONITOR_REQUEST_TIMEOUT_IN_MS) {
+    return MAX_MONITOR_REQUEST_TIMEOUT_IN_MS;
+  }
+  return value;
+};
+
+export const clampMonitorRetryCount: (value: number) => number = (
+  value: number,
+): number => {
+  if (value === undefined || value === null || isNaN(value) || value < 0) {
+    return DEFAULT_MONITOR_RETRY_COUNT;
+  }
+  if (value > MAX_MONITOR_RETRY_COUNT) {
+    return MAX_MONITOR_RETRY_COUNT;
+  }
+  return value;
+};
+
 export interface MonitorStepType {
   id: string;
   monitorDestination?: URL | IP | Hostname | undefined;
@@ -88,6 +121,19 @@ export interface MonitorStepType {
   // retry count for synthetic monitors - number of times to retry on error
   retryCountOnError?: number | undefined;
 
+  /*
+   * Per-step request timeout in milliseconds for probe-based monitors
+   * (Website, API, Ping, IP, Port, SSLCertificate). Defaults to and is
+   * capped at 60000 ms (60 seconds).
+   */
+  requestTimeoutInMs?: number | undefined;
+
+  /*
+   * Per-step retry count for probe-based monitors when a check fails.
+   * Defaults to and is capped at 3.
+   */
+  retryCount?: number | undefined;
+
   // Log monitor type.
   logMonitor?: MonitorStepLogMonitor | undefined;
 
@@ -148,6 +194,8 @@ export default class MonitorStep extends DatabaseProperty {
       screenSizeTypes: undefined,
       browserTypes: undefined,
       retryCountOnError: undefined,
+      requestTimeoutInMs: undefined,
+      retryCount: undefined,
       logMonitor: undefined,
       traceMonitor: undefined,
       metricMonitor: undefined,
@@ -190,6 +238,8 @@ export default class MonitorStep extends DatabaseProperty {
       screenSizeTypes: undefined,
       browserTypes: undefined,
       retryCountOnError: undefined,
+      requestTimeoutInMs: undefined,
+      retryCount: undefined,
       logMonitor: undefined,
       traceMonitor: undefined,
       metricMonitor: undefined,
@@ -294,6 +344,27 @@ export default class MonitorStep extends DatabaseProperty {
     return this;
   }
 
+  public setRequestTimeoutInMs(
+    requestTimeoutInMs: number | undefined,
+  ): MonitorStep {
+    if (requestTimeoutInMs === undefined) {
+      this.data!.requestTimeoutInMs = undefined;
+      return this;
+    }
+    this.data!.requestTimeoutInMs =
+      clampMonitorRequestTimeoutInMs(requestTimeoutInMs);
+    return this;
+  }
+
+  public setRetryCount(retryCount: number | undefined): MonitorStep {
+    if (retryCount === undefined) {
+      this.data!.retryCount = undefined;
+      return this;
+    }
+    this.data!.retryCount = clampMonitorRetryCount(retryCount);
+    return this;
+  }
+
   public setLogMonitor(logMonitor: MonitorStepLogMonitor): MonitorStep {
     this.data!.logMonitor = logMonitor;
     return this;
@@ -400,6 +471,8 @@ export default class MonitorStep extends DatabaseProperty {
         screenSizeTypes: undefined,
         browserTypes: undefined,
         retryCountOnError: undefined,
+        requestTimeoutInMs: undefined,
+        retryCount: undefined,
         logMonitor: undefined,
         exceptionMonitor: undefined,
         kubernetesMonitor: undefined,
@@ -597,6 +670,11 @@ export default class MonitorStep extends DatabaseProperty {
           screenSizeTypes: this.data.screenSizeTypes || undefined,
           browserTypes: this.data.browserTypes || undefined,
           retryCountOnError: this.data.retryCountOnError || undefined,
+          requestTimeoutInMs: this.data.requestTimeoutInMs || undefined,
+          retryCount:
+            this.data.retryCount === undefined
+              ? undefined
+              : this.data.retryCount,
           logMonitor: this.data.logMonitor
             ? MonitorStepLogMonitorUtil.toJSON(
                 this.data.logMonitor || MonitorStepLogMonitorUtil.getDefault(),
@@ -745,6 +823,11 @@ export default class MonitorStep extends DatabaseProperty {
         (json["screenSizeTypes"] as Array<ScreenSizeType>) || undefined,
       browserTypes: (json["browserTypes"] as Array<BrowserType>) || undefined,
       retryCountOnError: (json["retryCountOnError"] as number) || undefined,
+      requestTimeoutInMs: (json["requestTimeoutInMs"] as number) || undefined,
+      retryCount:
+        json["retryCount"] === undefined || json["retryCount"] === null
+          ? undefined
+          : (json["retryCount"] as number),
       logMonitor: json["logMonitor"]
         ? (json["logMonitor"] as JSONObject)
         : undefined,
@@ -806,6 +889,8 @@ export default class MonitorStep extends DatabaseProperty {
         screenSizeTypes: Zod.any().optional(),
         browserTypes: Zod.any().optional(),
         retryCountOnError: Zod.number().optional(),
+        requestTimeoutInMs: Zod.number().optional(),
+        retryCount: Zod.number().optional(),
         logMonitor: Zod.any().optional(),
         traceMonitor: Zod.any().optional(),
         metricMonitor: Zod.any().optional(),

package/Types/StatusPage/StatusPageGroupViewMode.ts

@@ -0,0 +1,6 @@
+enum StatusPageGroupViewMode {
+  List = "List",
+  Grid = "Grid",
+}
+
+export default StatusPageGroupViewMode;

package/UI/Components/Accordion/Accordion.tsx

@@ -75,7 +75,11 @@ const Accordion: FunctionComponent<ComponentProps> = (
     <div className={className}>
       <div>
         <div
-          className={`flex justify-between cursor-pointer`}
+          className={`flex justify-between ${
+            props.description ? "items-start" : "items-center"
+          } gap-3 cursor-pointer group/accordion-header rounded-lg -mx-2 px-2 py-2 transition-colors ${
+            isOpen ? "" : "hover:bg-gray-50/80"
+          }`}
           role="button"
           tabIndex={0}
           aria-expanded={isOpen}
@@ -85,43 +89,53 @@ const Accordion: FunctionComponent<ComponentProps> = (
           }}
           onKeyDown={handleKeyDown}
         >
-          <div className="flex">
+          <div
+            className={`flex ${
+              props.description ? "items-start" : "items-center"
+            } min-w-0 flex-1`}
+          >
             {props.title && (
-              <div>
-                {isOpen && (
-                  <Icon
-                    className="h-4 w-4 text-gray-500"
-                    icon={IconProp.ChevronDown}
-                    thick={ThickProp.Thick}
-                  />
-                )}
-                {!isOpen && (
-                  <Icon
-                    className="h-4 w-4 text-gray-500"
-                    icon={IconProp.ChevronRight}
-                    thick={ThickProp.Thick}
-                  />
-                )}
+              <div
+                className={`flex-shrink-0 ${
+                  props.description ? "mt-0.5" : ""
+                } flex items-center justify-center w-6 h-6 rounded-md transition-all duration-200 ${
+                  isOpen
+                    ? "bg-gray-900/5 text-gray-700"
+                    : "text-gray-400 group-hover/accordion-header:bg-gray-900/5 group-hover/accordion-header:text-gray-700"
+                }`}
+                aria-hidden="true"
+              >
+                <Icon
+                  className={`h-3.5 w-3.5 transition-transform duration-200 ease-out ${
+                    isOpen ? "rotate-90" : ""
+                  }`}
+                  icon={IconProp.ChevronRight}
+                  thick={ThickProp.Thick}
+                />
               </div>
             )}
             {props.title && (
               <div
-                className={`ml-1 -mt-1 ${
+                className={`ml-2.5 min-w-0 flex-1 ${
                   props.onClick ? "cursor-pointer" : ""
                 }`}
               >
-                <div className={`text-gray-500 ${props.titleClassName}`}>
-                  {props.title}{" "}
-                </div>
-                <div className="mb-2 text-sm">
-                  {props.description && (
-                    <MarkdownViewer text={props.description || ""} />
-                  )}
+                <div
+                  className={`text-gray-900 leading-snug ${props.titleClassName || ""}`}
+                >
+                  {props.title}
                 </div>
+                {props.description && (
+                  <div className="mt-1 text-sm text-gray-500 leading-relaxed">
+                    <MarkdownViewer text={props.description} />
+                  </div>
+                )}
               </div>
             )}
           </div>
-          {!isOpen && <div className="">{props.rightElement}</div>}
+          {!isOpen && props.rightElement && (
+            <div className="flex-shrink-0">{props.rightElement}</div>
+          )}
         </div>
         {isOpen && (
           <div