@oneuptime/common 10.0.70 → 10.0.72

package/Tests/Server/Utils/Monitor/Criteria/MetricMonitorCriteria.test.ts

@@ -1,4 +1,5 @@
 import MetricMonitorCriteria from "../../../../../Server/Utils/Monitor/Criteria/MetricMonitorCriteria";
+import MetricSeriesFingerprint from "../../../../../Utils/Metrics/MetricSeriesFingerprint";
 import AggregateModel from "../../../../../Types/BaseDatabase/AggregatedModel";
 import AggregatedResult from "../../../../../Types/BaseDatabase/AggregatedResult";
 import {
@@ -500,3 +501,270 @@ describe("MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
     expect(message).not.toContain("110, 120, 130, 140, 150, 160");
   });
 });
+
+describe("MetricMonitorCriteria.evaluateAllSeries — per-host alerting", () => {
+  /*
+   * Build a fixture whose metric response carries a pre-computed
+   * seriesBreakdown with two hosts over threshold and one under. This
+   * mirrors what MonitorTelemetryMonitor produces when groupByAttributeKeys
+   * is set.
+   */
+  function buildInputsWithSeriesBreakdown(input: {
+    criteriaFilter: CriteriaFilter;
+    seriesSamples: Array<{
+      labels: Record<string, string>;
+      values: Array<number>;
+    }>;
+  }): {
+    criteriaFilter: CriteriaFilter;
+    monitorStep: MonitorStep;
+    dataToProcess: MetricMonitorResponse;
+  } {
+    const aliasData: MetricAliasData = {
+      metricVariable: "a",
+      title: "CPU",
+      description: undefined,
+      legend: undefined,
+      legendUnit: "%",
+    };
+
+    const queryConfig: MetricQueryConfigData = {
+      metricAliasData: aliasData,
+      metricQueryData: {
+        filterData: {
+          metricName: "cpu.usage",
+        },
+        groupByAttributeKeys: ["host.name"],
+      } as unknown as MetricQueryData,
+    };
+
+    const metricViewConfig: MetricsViewConfig = {
+      queryConfigs: [queryConfig],
+      formulaConfigs: [],
+    };
+
+    const monitorStep: MonitorStep = new MonitorStep();
+    monitorStep.data = {
+      id: ObjectID.generate().toString(),
+      monitorCriteria: { data: undefined } as never,
+    } as unknown as MonitorStep["data"];
+    monitorStep.data!.metricMonitor = {
+      metricViewConfig,
+      rollingTime: RollingTime.Past1Minute,
+    };
+
+    const seriesBreakdown: Array<{
+      fingerprint: string;
+      labels: Record<string, string>;
+      aggregatedResults: Array<AggregatedResult>;
+    }> = input.seriesSamples.map(
+      (s: { labels: Record<string, string>; values: Array<number> }) => {
+        return {
+          fingerprint: Object.values(s.labels).join("|"),
+          labels: s.labels,
+          aggregatedResults: [
+            {
+              data: s.values.map((v: number) => {
+                return {
+                  timestamp: new Date(),
+                  value: v,
+                  attributes: s.labels,
+                } as unknown as AggregateModel;
+              }),
+            } as AggregatedResult,
+          ],
+        };
+      },
+    );
+
+    // Flat metricResult = union of all series samples, mirroring the worker.
+    const flatData: Array<AggregateModel> = input.seriesSamples.flatMap(
+      (s: { labels: Record<string, string>; values: Array<number> }) => {
+        return s.values.map((v: number) => {
+          return {
+            timestamp: new Date(),
+            value: v,
+            attributes: s.labels,
+          } as unknown as AggregateModel;
+        });
+      },
+    );
+
+    const dataToProcess: MetricMonitorResponse = {
+      projectId: ObjectID.generate(),
+      metricResult: [{ data: flatData } as AggregatedResult],
+      metricViewConfig,
+      monitorId: ObjectID.generate(),
+      seriesBreakdown:
+        seriesBreakdown as unknown as MetricMonitorResponse["seriesBreakdown"],
+    };
+
+    return {
+      criteriaFilter: input.criteriaFilter,
+      monitorStep,
+      dataToProcess,
+    };
+  }
+
+  test("no seriesBreakdown → single synthetic evaluation (backward compatible)", () => {
+    const criteriaFilter: CriteriaFilter = {
+      checkOn: CheckOn.MetricValue,
+      filterType: FilterType.GreaterThan,
+      value: "80",
+      metricMonitorOptions: {
+        metricAlias: "a",
+        metricAggregationType: EvaluateOverTimeType.AnyValue,
+      },
+    };
+
+    const inputs: ReturnType<typeof buildInputs> = buildInputs({
+      metricNativeUnit: "%",
+      sampleValues: [95],
+      criteriaFilter,
+    });
+
+    const results: ReturnType<typeof MetricMonitorCriteria.evaluateAllSeries> =
+      MetricMonitorCriteria.evaluateAllSeries(inputs);
+    expect(results).toHaveLength(1);
+    expect(results[0]!.fingerprint).toBeUndefined();
+    expect(results[0]!.rootCause).toBeTruthy();
+  });
+
+  test("seriesBreakdown with 2 breaching + 1 non-breaching → only breaching series return rootCause", () => {
+    const criteriaFilter: CriteriaFilter = {
+      checkOn: CheckOn.MetricValue,
+      filterType: FilterType.GreaterThan,
+      value: "80",
+      metricMonitorOptions: {
+        metricAlias: "a",
+        metricAggregationType: EvaluateOverTimeType.AnyValue,
+      },
+    };
+
+    const inputs: ReturnType<typeof buildInputsWithSeriesBreakdown> =
+      buildInputsWithSeriesBreakdown({
+        criteriaFilter,
+        seriesSamples: [
+          { labels: { "host.name": "prod-01" }, values: [95] },
+          { labels: { "host.name": "prod-02" }, values: [92] },
+          { labels: { "host.name": "prod-03" }, values: [50] },
+        ],
+      });
+
+    const results: ReturnType<typeof MetricMonitorCriteria.evaluateAllSeries> =
+      MetricMonitorCriteria.evaluateAllSeries(inputs);
+    expect(results).toHaveLength(3);
+
+    const breaching: typeof results = results.filter(
+      (r: (typeof results)[number]) => {
+        return r.rootCause !== null;
+      },
+    );
+    expect(breaching).toHaveLength(2);
+
+    const breachingHosts: Array<string> = breaching
+      .map((r: (typeof results)[number]) => {
+        return r.labels["host.name"] as string;
+      })
+      .sort();
+    expect(breachingHosts).toEqual(["prod-01", "prod-02"]);
+  });
+
+  test("each series gets its own breaching-samples context", () => {
+    const criteriaFilter: CriteriaFilter = {
+      checkOn: CheckOn.MetricValue,
+      filterType: FilterType.GreaterThan,
+      value: "80",
+      metricMonitorOptions: {
+        metricAlias: "a",
+        metricAggregationType: EvaluateOverTimeType.AnyValue,
+      },
+    };
+
+    const inputs: ReturnType<typeof buildInputsWithSeriesBreakdown> =
+      buildInputsWithSeriesBreakdown({
+        criteriaFilter,
+        seriesSamples: [
+          { labels: { "host.name": "prod-01" }, values: [95, 97] },
+          { labels: { "host.name": "prod-02" }, values: [92] },
+        ],
+      });
+
+    const results: ReturnType<typeof MetricMonitorCriteria.evaluateAllSeries> =
+      MetricMonitorCriteria.evaluateAllSeries(inputs);
+    const prod01: (typeof results)[number] = results.find(
+      (r: (typeof results)[number]) => {
+        return r.labels["host.name"] === "prod-01";
+      },
+    )!;
+    const prod02: (typeof results)[number] = results.find(
+      (r: (typeof results)[number]) => {
+        return r.labels["host.name"] === "prod-02";
+      },
+    )!;
+
+    expect(prod01.context.breachingSamples).toHaveLength(2);
+    expect(prod02.context.breachingSamples).toHaveLength(1);
+    expect(prod01.context.seriesLabels).toEqual({ "host.name": "prod-01" });
+  });
+});
+
+describe("MetricSeriesFingerprint", () => {
+  test("fingerprint is stable regardless of key order", () => {
+    const a: { [k: string]: string } = {
+      "host.name": "prod-01",
+      region: "us-east",
+    };
+    const b: { [k: string]: string } = {
+      region: "us-east",
+      "host.name": "prod-01",
+    };
+
+    expect(MetricSeriesFingerprint.computeFingerprint(a)).toBe(
+      MetricSeriesFingerprint.computeFingerprint(b),
+    );
+  });
+
+  test("different label values → different fingerprints", () => {
+    expect(
+      MetricSeriesFingerprint.computeFingerprint({ "host.name": "prod-01" }),
+    ).not.toBe(
+      MetricSeriesFingerprint.computeFingerprint({ "host.name": "prod-02" }),
+    );
+  });
+
+  test("empty labels → sentinel WholeMonitorFingerprint", () => {
+    expect(MetricSeriesFingerprint.computeFingerprint({})).toBe(
+      MetricSeriesFingerprint.WholeMonitorFingerprint,
+    );
+  });
+
+  test("missing attribute keys canonicalize to empty string (stable fingerprint)", () => {
+    const sample1: AggregateModel = {
+      timestamp: new Date(),
+      value: 42,
+      attributes: { "host.name": "prod-01" },
+    } as unknown as AggregateModel;
+    const sample2: AggregateModel = {
+      timestamp: new Date(),
+      value: 42,
+      attributes: { "host.name": "prod-01", region: "us-east" },
+    } as unknown as AggregateModel;
+
+    const labels1: import("../../../../../Types/JSON").JSONObject =
+      MetricSeriesFingerprint.extractSeriesLabels({
+        sample: sample1,
+        attributeKeys: ["host.name"],
+      });
+    const labels2: import("../../../../../Types/JSON").JSONObject =
+      MetricSeriesFingerprint.extractSeriesLabels({
+        sample: sample2,
+        attributeKeys: ["host.name"],
+      });
+
+    // When only host.name is selected, region doesn't affect the fingerprint
+    expect(MetricSeriesFingerprint.computeFingerprint(labels1)).toBe(
+      MetricSeriesFingerprint.computeFingerprint(labels2),
+    );
+  });
+});

package/Types/BaseDatabase/IncludesNone.ts

@@ -4,10 +4,7 @@ import JSONFunctions from "../JSONFunctions";
 import ObjectID from "../ObjectID";
 import QueryOperator from "./QueryOperator";
 
-export type IncludesNoneType =
-  | Array<string>
-  | Array<ObjectID>
-  | Array<number>;
+export type IncludesNoneType = Array<string> | Array<ObjectID> | Array<number>;
 
 export default class IncludesNone extends QueryOperator<IncludesNoneType> {
   private _values: IncludesNoneType = [];

package/Types/Email.ts

@@ -75,6 +75,56 @@ export default class Email extends DatabaseProperty {
     return new Email(value);
   }
 
+  public static parseList(value: string | null | undefined): Array<Email> {
+    if (!value) {
+      return [];
+    }
+
+    const seen: Set<string> = new Set<string>();
+    const emails: Array<Email> = [];
+
+    for (const part of value.split(/[,;\s]+/)) {
+      const trimmed: string = part.trim();
+      if (!trimmed) {
+        continue;
+      }
+      const email: Email = new Email(trimmed);
+      const key: string = email.toString();
+      if (!seen.has(key)) {
+        seen.add(key);
+        emails.push(email);
+      }
+    }
+
+    return emails;
+  }
+
+  public static isValidList(value: string | null | undefined): boolean {
+    if (!value) {
+      return true;
+    }
+
+    const parts: Array<string> = value
+      .split(/[,;\s]+/)
+      .map((p: string): string => {
+        return p.trim();
+      })
+      .filter((p: string): boolean => {
+        return p.length > 0;
+      });
+
+    if (parts.length === 0) {
+      return false;
+    }
+
+    for (const part of parts) {
+      if (!Email.isValid(part)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   public static override fromJSON(json: JSONObject): Email {
     if (json["_type"] === ObjectType.Email) {
       return new Email((json["value"] as string) || "");

package/Types/Infrastructure/BasicMetrics.ts

@@ -4,11 +4,30 @@ export interface MemoryMetrics {
   used: number;
   percentUsed: number;
   percentFree: number;
+
+  available?: number | undefined;
+  buffers?: number | undefined;
+  cached?: number | undefined;
+
+  swapTotal?: number | undefined;
+  swapUsed?: number | undefined;
+  swapFree?: number | undefined;
+  swapPercentUsed?: number | undefined;
 }
 
 export interface CPUMetrics {
   percentUsed: number;
   cores: number;
+
+  perCorePercent?: Array<number> | undefined;
+  timeUserPercent?: number | undefined;
+  timeSystemPercent?: number | undefined;
+  timeIdlePercent?: number | undefined;
+  timeIoWaitPercent?: number | undefined;
+  timeStealPercent?: number | undefined;
+  timeNicePercent?: number | undefined;
+  timeIrqPercent?: number | undefined;
+  timeSoftIrqPercent?: number | undefined;
 }
 
 export interface BasicDiskMetrics {
@@ -18,10 +37,66 @@ export interface BasicDiskMetrics {
   diskPath: string;
   percentUsed: number;
   percentFree: number;
+
+  device?: string | undefined;
+  fstype?: string | undefined;
+  readBytes?: number | undefined;
+  writeBytes?: number | undefined;
+  readCount?: number | undefined;
+  writeCount?: number | undefined;
+  ioTimeMs?: number | undefined;
+}
+
+export interface NetworkInterfaceMetrics {
+  interfaceName: string;
+  bytesReceived: number;
+  bytesSent: number;
+  packetsReceived: number;
+  packetsSent: number;
+  errorsIn: number;
+  errorsOut: number;
+  dropsIn: number;
+  dropsOut: number;
+}
+
+export interface NetworkMetrics {
+  interfaces?: Array<NetworkInterfaceMetrics> | undefined;
+  totalBytesReceived?: number | undefined;
+  totalBytesSent?: number | undefined;
+  totalPacketsReceived?: number | undefined;
+  totalPacketsSent?: number | undefined;
+  connectionsEstablished?: number | undefined;
+  connectionsListen?: number | undefined;
+  connectionsTotal?: number | undefined;
+}
+
+export interface LoadMetrics {
+  load1: number;
+  load5: number;
+  load15: number;
+}
+
+export interface HostMetrics {
+  platform?: string | undefined;
+  platformFamily?: string | undefined;
+  platformVersion?: string | undefined;
+  kernelVersion?: string | undefined;
+  kernelArch?: string | undefined;
+  os?: string | undefined;
+  uptimeSeconds?: number | undefined;
+  bootTime?: number | undefined;
+  hostId?: string | undefined;
+  virtualizationSystem?: string | undefined;
+  virtualizationRole?: string | undefined;
+  numProcesses?: number | undefined;
 }
 
 export default interface BasicInfrastructureMetrics {
   cpuMetrics: CPUMetrics;
   memoryMetrics: MemoryMetrics;
   diskMetrics: Array<BasicDiskMetrics>;
+
+  networkMetrics?: NetworkMetrics | undefined;
+  loadMetrics?: LoadMetrics | undefined;
+  hostMetrics?: HostMetrics | undefined;
 }

package/Types/Metrics/MetricQueryData.ts

@@ -6,4 +6,15 @@ import MetricsQuery from "./MetricsQuery";
 export default interface MetricQueryData {
   filterData: FilterData<MetricsQuery>;
   groupBy?: GroupBy<Metric> | undefined;
+  /**
+   * OpenTelemetry attribute keys (e.g. "host.name", "service.name") to
+   * group this query by. Stored alongside groupBy because attributes
+   * live inside a nested Map column and can't be expressed through
+   * GroupBy<Metric>, which only references top-level columns.
+   *
+   * When set, the monitor worker emits one series per unique value
+   * combination of these keys — enabling per-host (or per-service, per-
+   * whatever) incident creation from a single metric monitor.
+   */
+  groupByAttributeKeys?: Array<string> | undefined;
 }

package/Types/Monitor/CriteriaFilter.ts

@@ -19,6 +19,11 @@ export enum CheckOn {
   DiskUsagePercent = "Disk Usage (in %)",
   CPUUsagePercent = "CPU Usage (in %)",
   MemoryUsagePercent = "Memory Usage (in %)",
+  LoadAverage1Min = "Load Average (1 minute)",
+  LoadAverage5Min = "Load Average (5 minute)",
+  LoadAverage15Min = "Load Average (15 minute)",
+  SwapUsagePercent = "Swap Usage (in %)",
+  CPUIoWaitPercent = "CPU IO Wait (in %)",
   ExpiresInHours = "Expires In Hours",
   ExpiresInDays = "Expires In Days",
   IsSelfSignedCertificate = "Is Self Signed Certificate",
@@ -296,6 +301,11 @@ export class CriteriaFilterUtil {
       checkOn === CheckOn.DiskUsagePercent ||
       checkOn === CheckOn.CPUUsagePercent ||
       checkOn === CheckOn.MemoryUsagePercent ||
+      checkOn === CheckOn.LoadAverage1Min ||
+      checkOn === CheckOn.LoadAverage5Min ||
+      checkOn === CheckOn.LoadAverage15Min ||
+      checkOn === CheckOn.SwapUsagePercent ||
+      checkOn === CheckOn.CPUIoWaitPercent ||
       checkOn === CheckOn.IsOnline ||
       checkOn === CheckOn.SnmpResponseTime ||
       checkOn === CheckOn.SnmpIsOnline ||

package/Types/Monitor/MetricMonitor/MetricCriteriaContext.ts

@@ -47,6 +47,17 @@ export default interface MetricCriteriaContext {
   filterAttributes: JSONObject;
   groupBy: Array<string>;
   timeWindowMinutes?: number | undefined;
+  /**
+   * Fingerprint of the specific series this context represents when the
+   * monitor is configured for per-series alerting. Undefined for
+   * traditional whole-monitor evaluation.
+   */
+  seriesFingerprint?: string | undefined;
+  /**
+   * Label values identifying the series (e.g. {host.name: prod-01}).
+   * Populated alongside seriesFingerprint.
+   */
+  seriesLabels?: JSONObject | undefined;
   breachingSample?: MetricBreachingSample | undefined;
   /**
    * All samples in the evaluation window that breached the threshold,

package/Types/Monitor/MetricMonitor/MetricMonitorResponse.ts

@@ -4,6 +4,7 @@ import MonitorEvaluationSummary from "../MonitorEvaluationSummary";
 import MetricsViewConfig from "../../Metrics/MetricsViewConfig";
 import ObjectID from "../../ObjectID";
 import Dictionary from "../../Dictionary";
+import MetricSeriesResult from "./MetricSeriesResult";
 
 export interface KubernetesAffectedResource {
   podName?: string | undefined;
@@ -31,4 +32,13 @@ export default interface MetricMonitorResponse {
   monitorId: ObjectID;
   evaluationSummary?: MonitorEvaluationSummary | undefined;
   kubernetesResourceBreakdown?: KubernetesResourceBreakdown | undefined;
+  /**
+   * Per-series breakdown when any queryConfig sets groupByAttributeKeys.
+   * Each entry carries a fingerprint, the label values identifying that
+   * series, and the aggregated-per-query results scoped to that series
+   * (including per-series formula results). Absent for traditional
+   * whole-monitor evaluation, in which case criteria evaluate against
+   * `metricResult` as before.
+   */
+  seriesBreakdown?: Array<MetricSeriesResult> | undefined;
 }

package/Types/Monitor/MetricMonitor/MetricSeriesResult.ts

@@ -0,0 +1,20 @@
+import AggregatedResult from "../../BaseDatabase/AggregatedResult";
+import { JSONObject } from "../../JSON";
+
+/**
+ * One series within a metric monitor evaluation. When a metric monitor
+ * is configured with group-by attributes (e.g. host.name), the worker
+ * splits the aggregated results into one entry per unique label
+ * combination. Each series is then evaluated independently so the
+ * criteria can fire one incident per affected series.
+ *
+ * `aggregatedResults` is aligned with the monitor's queryConfigs +
+ * formulaConfigs arrays (same length, same order) so per-series
+ * formula evaluation reuses the same indexing the criteria evaluator
+ * expects.
+ */
+export default interface MetricSeriesResult {
+  fingerprint: string;
+  labels: JSONObject;
+  aggregatedResults: Array<AggregatedResult>;
+}

package/Types/Monitor/MonitorMetricType.ts

@@ -6,6 +6,40 @@ enum MonitorMetricType {
   MemoryUsagePercent = "oneuptime.monitor.memory.usage.percent",
   IsOnline = "oneuptime.monitor.online",
   ExecutionTime = "oneuptime.monitor.execution.time",
+
+  /*
+   * Extended server/VM metrics. Emitted when the agent payload contains them;
+   * absent for older agents, which keeps the pipeline backwards-compatible.
+   */
+  LoadAverage1Min = "oneuptime.monitor.load.avg.1min",
+  LoadAverage5Min = "oneuptime.monitor.load.avg.5min",
+  LoadAverage15Min = "oneuptime.monitor.load.avg.15min",
+
+  SwapUsagePercent = "oneuptime.monitor.memory.swap.usage.percent",
+  MemoryAvailableBytes = "oneuptime.monitor.memory.available.bytes",
+
+  CPUTimeUserPercent = "oneuptime.monitor.cpu.time.user.percent",
+  CPUTimeSystemPercent = "oneuptime.monitor.cpu.time.system.percent",
+  CPUTimeIoWaitPercent = "oneuptime.monitor.cpu.time.iowait.percent",
+  CPUTimeIdlePercent = "oneuptime.monitor.cpu.time.idle.percent",
+  CPUTimeStealPercent = "oneuptime.monitor.cpu.time.steal.percent",
+
+  DiskReadBytesTotal = "oneuptime.monitor.disk.io.read.bytes.total",
+  DiskWriteBytesTotal = "oneuptime.monitor.disk.io.write.bytes.total",
+  DiskReadOpsTotal = "oneuptime.monitor.disk.io.read.ops.total",
+  DiskWriteOpsTotal = "oneuptime.monitor.disk.io.write.ops.total",
+
+  NetworkBytesReceivedTotal = "oneuptime.monitor.network.bytes.received.total",
+  NetworkBytesSentTotal = "oneuptime.monitor.network.bytes.sent.total",
+  NetworkPacketsReceivedTotal = "oneuptime.monitor.network.packets.received.total",
+  NetworkPacketsSentTotal = "oneuptime.monitor.network.packets.sent.total",
+  NetworkErrorsIn = "oneuptime.monitor.network.errors.in",
+  NetworkErrorsOut = "oneuptime.monitor.network.errors.out",
+  NetworkConnectionsEstablished = "oneuptime.monitor.network.connections.established",
+  NetworkConnectionsListen = "oneuptime.monitor.network.connections.listen",
+
+  HostUptimeSeconds = "oneuptime.monitor.host.uptime.seconds",
+  ProcessCountTotal = "oneuptime.monitor.process.count.total",
 }
 
 export default MonitorMetricType;

package/Types/Monitor/ServerMonitor/ServerMonitorResponse.ts

@@ -6,6 +6,14 @@ export interface ServerProcess {
   pid: number;
   name: string;
   command: string;
+
+  cpuPercent?: number | undefined;
+  memoryBytes?: number | undefined;
+  memoryPercent?: number | undefined;
+  status?: string | undefined;
+  threads?: number | undefined;
+  createTimeMs?: number | undefined;
+  username?: string | undefined;
 }
 
 export default interface ServerMonitorResponse {

package/Types/Probe/ProbeApiIngestResponse.ts

@@ -1,5 +1,22 @@
 import ObjectID from "../ObjectID";
 import MonitorEvaluationSummary from "../Monitor/MonitorEvaluationSummary";
+import { JSONObject } from "../JSON";
+import MetricCriteriaContext from "../Monitor/MetricMonitor/MetricCriteriaContext";
+
+/**
+ * One per-series match produced by a metric monitor with
+ * groupByAttributeKeys set. The criteria evaluator emits an entry per
+ * series that breached the threshold, and MonitorResource fans this
+ * out into one incident + one alert per (criteria, incident template,
+ * fingerprint) triple.
+ */
+export interface PerSeriesCriteriaMatch {
+  criteriaMetId: string;
+  fingerprint: string;
+  labels: JSONObject;
+  rootCause: string;
+  metricContext?: MetricCriteriaContext | undefined;
+}
 
 export default interface ProbeApiIngestResponse {
   monitorId: ObjectID;
@@ -8,4 +25,12 @@ export default interface ProbeApiIngestResponse {
   criteriaMetId?: string | undefined;
   rootCause: string | null; // this is in markdown format
   evaluationSummary?: MonitorEvaluationSummary | undefined;
+  /**
+   * Set when a metric monitor with group-by attributes produced one or
+   * more per-series matches. MonitorResource uses this to create one
+   * incident/alert per breaching series. When undefined (non-metric
+   * monitors or ungrouped metric monitors), the scalar `criteriaMetId`
+   * + `rootCause` still drive the legacy single-incident path.
+   */
+  perSeriesMatches?: Array<PerSeriesCriteriaMatch> | undefined;
 }

package/Types/StatusPage/StatusPageLanguage.ts

@@ -0,0 +1,29 @@
+export interface StatusPageLanguage {
+  code: string;
+  nativeName: string;
+  englishName: string;
+}
+
+export const DEFAULT_STATUS_PAGE_LANGUAGE: string = "en";
+
+export const SUPPORTED_STATUS_PAGE_LANGUAGES: Array<StatusPageLanguage> = [
+  { 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" },
+];
+
+export const SUPPORTED_STATUS_PAGE_LANGUAGE_CODES: Array<string> =
+  SUPPORTED_STATUS_PAGE_LANGUAGES.map((language: StatusPageLanguage) => {
+    return language.code;
+  });