@oneuptime/common 10.0.71 → 10.0.72

package/Server/Utils/Monitor/MonitorIncident.ts

@@ -29,6 +29,7 @@ import { JSONObject } from "../../../Types/JSON";
 import OneUptimeDate from "../../../Types/Date";
 import MonitorEvaluationSummary from "../../../Types/Monitor/MonitorEvaluationSummary";
 import { IncidentMemberRoleAssignment } from "../../../Types/Monitor/CriteriaIncident";
+import { PerSeriesCriteriaMatch } from "../../../Types/Probe/ProbeApiIngestResponse";
 
 export default class MonitorIncident {
   @CaptureSpan()
@@ -41,6 +42,15 @@ export default class MonitorIncident {
     criteriaInstance: MonitorCriteriaInstance | null;
     dataToProcess: DataToProcess;
     evaluationSummary?: MonitorEvaluationSummary | undefined;
+    /**
+     * When set, the fingerprint set of series still breaching on this
+     * tick. Any open per-series incident whose fingerprint is NOT in
+     * this set is auto-resolved — that's how a series returning to
+     * normal closes its incident independently of other series on the
+     * same monitor. Undefined means "legacy mode" and per-series
+     * incidents are treated like any other for dedupe/resolve.
+     */
+    breachingSeriesFingerprints?: Set<string> | undefined;
   }): Promise<Array<Incident>> {
     // check active incidents and if there are open incidents, do not cretae anothr incident.
     const openIncidents: Array<Incident> = await IncidentService.findBy({
@@ -54,12 +64,15 @@ export default class MonitorIncident {
       limit: LIMIT_PER_PROJECT,
       select: {
         _id: true,
+        title: true,
         createdCriteriaId: true,
         createdIncidentTemplateId: true,
         projectId: true,
         incidentNumber: true,
         incidentNumberWithPrefix: true,
         currentIncidentStateId: true,
+        seriesFingerprint: true,
+        seriesLabels: true,
       },
       props: {
         isRoot: true,
@@ -74,6 +87,7 @@ export default class MonitorIncident {
         autoResolveCriteriaInstanceIdIncidentIdsDictionary:
           input.autoResolveCriteriaInstanceIdIncidentIdsDictionary,
         criteriaInstance: input.criteriaInstance,
+        breachingSeriesFingerprints: input.breachingSeriesFingerprints,
       });
 
       if (shouldClose) {
@@ -115,6 +129,13 @@ export default class MonitorIncident {
     props: {
       telemetryQuery?: TelemetryQuery | undefined;
     };
+    /**
+     * When set, create one incident per series instead of one per
+     * monitor. Each entry gets its own rootCause, seriesFingerprint,
+     * and seriesLabels so the incident title + description can
+     * reference `{{host.name}}` etc. via the template engine.
+     */
+    matchesPerSeries?: Array<PerSeriesCriteriaMatch> | undefined;
   }): Promise<void> {
     const incidentLogAttributes: LogAttributes = {
       projectId: input.monitor.projectId?.toString(),
@@ -125,6 +146,21 @@ export default class MonitorIncident {
       `${input.monitor.id?.toString()} - Check open incidents.`,
       incidentLogAttributes,
     );
+
+    /*
+     * Per-series mode: close any open incident for a series that's no
+     * longer breaching *before* we look at the remaining open set, so
+     * dedupe decisions below match the post-resolve state.
+     */
+    const breachingSeriesFingerprints: Set<string> | undefined =
+      input.matchesPerSeries
+        ? new Set<string>(
+            input.matchesPerSeries.map((m: PerSeriesCriteriaMatch) => {
+              return m.fingerprint;
+            }),
+          )
+        : undefined;
+
     // check active incidents and if there are open incidents, do not cretae anothr incident.
     const openIncidents: Array<Incident> =
       await this.checkOpenIncidentsAndCloseIfResolved({
@@ -135,14 +171,29 @@ export default class MonitorIncident {
         criteriaInstance: input.criteriaInstance,
         dataToProcess: input.dataToProcess,
         evaluationSummary: input.evaluationSummary,
+        breachingSeriesFingerprints,
       });
 
-    if (input.criteriaInstance.data?.createIncidents) {
-      // create incidents
+    if (!input.criteriaInstance.data?.createIncidents) {
+      return;
+    }
 
-      for (const criteriaIncident of input.criteriaInstance.data?.incidents ||
-        []) {
-        // should create incident.
+    /*
+     * Series-less path: one incident per criteriaIncident template as
+     * before. Series-aware path: one incident per (series × template).
+     */
+    const seriesToProcess: Array<PerSeriesCriteriaMatch | undefined> =
+      input.matchesPerSeries && input.matchesPerSeries.length > 0
+        ? input.matchesPerSeries
+        : [undefined];
+
+    for (const criteriaIncident of input.criteriaInstance.data?.incidents ||
+      []) {
+      for (const seriesMatch of seriesToProcess) {
+        const seriesFingerprint: string | undefined = seriesMatch?.fingerprint;
+        const seriesLabels: JSONObject | undefined = seriesMatch?.labels;
+        const seriesRootCause: string =
+          seriesMatch?.rootCause || input.rootCause;
 
         const alreadyOpenIncident: Incident | undefined = openIncidents.find(
           (incident: Incident) => {
@@ -150,7 +201,8 @@ export default class MonitorIncident {
               incident.createdCriteriaId ===
                 input.criteriaInstance.data?.id.toString() &&
               incident.createdIncidentTemplateId ===
-                criteriaIncident.id.toString()
+                criteriaIncident.id.toString() &&
+              (incident.seriesFingerprint || undefined) === seriesFingerprint
             );
           },
         );
@@ -168,9 +220,20 @@ export default class MonitorIncident {
         );
 
         if (hasAlreadyOpenIncident) {
+          /*
+           * Use the open incident's already-rendered title when
+           * available — the template (`criteriaIncident.title`) still
+           * contains unresolved `{{…}}` placeholders because it's the
+           * criterion's template string, not the instance's rendered
+           * output. Falling back to the template only when the open
+           * incident somehow has no title.
+           */
+          const renderedTitle: string =
+            alreadyOpenIncident?.title || criteriaIncident.title;
+
           input.evaluationSummary?.events.push({
             type: "incident-skipped",
-            title: `Incident already active: ${criteriaIncident.title}`,
+            title: `Incident already active: ${renderedTitle}`,
             message:
               "Skipped creating a new incident because an active incident exists for this criteria.",
             relatedCriteriaId: input.criteriaInstance.data?.id,
@@ -193,6 +256,8 @@ export default class MonitorIncident {
           MonitorTemplateUtil.buildTemplateStorageMap({
             monitorType: input.monitor.monitorType!,
             dataToProcess: input.dataToProcess,
+            monitor: input.monitor,
+            seriesLabels,
           });
 
         incident.title = MonitorTemplateUtil.processTemplateString({
@@ -236,7 +301,7 @@ export default class MonitorIncident {
 
         incident.monitors = [input.monitor];
         incident.projectId = input.monitor.projectId!;
-        incident.rootCause = input.rootCause;
+        incident.rootCause = seriesRootCause;
         incident.createdStateLog = JSON.parse(
           JSON.stringify(input.dataToProcess, null, 2),
         );
@@ -245,6 +310,13 @@ export default class MonitorIncident {
 
         incident.createdIncidentTemplateId = criteriaIncident.id.toString();
 
+        if (seriesFingerprint) {
+          incident.seriesFingerprint = seriesFingerprint;
+        }
+        if (seriesLabels && Object.keys(seriesLabels).length > 0) {
+          incident.seriesLabels = seriesLabels;
+        }
+
         incident.onCallDutyPolicies =
           criteriaIncident.onCallPolicyIds?.map((id: ObjectID) => {
             const onCallPolicy: OnCallDutyPolicy = new OnCallDutyPolicy();
@@ -504,7 +576,60 @@ export default class MonitorIncident {
       Array<string>
     >;
     criteriaInstance: MonitorCriteriaInstance | null; // null if no criteia met.
+    breachingSeriesFingerprints?: Set<string> | undefined;
   }): boolean {
+    const openSeriesFingerprint: string | undefined =
+      input.openIncident.seriesFingerprint || undefined;
+
+    /*
+     * Per-series auto-resolve: when the monitor emits a breaching-
+     * series set and this open incident has a fingerprint, resolve
+     * whenever the fingerprint is no longer in the set — regardless
+     * of whether some *other* series is still breaching the same
+     * criteria. This is the whole point of per-host incidents.
+     */
+    if (
+      input.breachingSeriesFingerprints !== undefined &&
+      openSeriesFingerprint
+    ) {
+      const stillBreaching: boolean = input.breachingSeriesFingerprints.has(
+        openSeriesFingerprint,
+      );
+
+      if (stillBreaching) {
+        return false;
+      }
+
+      /*
+       * Series no longer breaching. Only auto-close if the criteria
+       * was configured to auto-resolve in the first place; otherwise
+       * stay open so a human can acknowledge.
+       */
+      if (!input.openIncident.createdCriteriaId?.toString()) {
+        return false;
+      }
+
+      if (!input.openIncident.createdIncidentTemplateId?.toString()) {
+        return false;
+      }
+
+      const autoResolveTemplates: Array<string> | undefined =
+        input.autoResolveCriteriaInstanceIdIncidentIdsDictionary[
+          input.openIncident.createdCriteriaId.toString()
+        ];
+
+      if (
+        autoResolveTemplates &&
+        autoResolveTemplates.includes(
+          input.openIncident.createdIncidentTemplateId.toString(),
+        )
+      ) {
+        return true;
+      }
+
+      return false;
+    }
+
     if (
       input.openIncident.createdCriteriaId?.toString() ===
       input.criteriaInstance?.data?.id.toString()

package/Server/Utils/Monitor/MonitorMetricUtil.ts

@@ -10,7 +10,9 @@ import {
   ServiceType,
 } from "../../../Models/AnalyticsModels/Metric";
 import MetricType from "../../../Models/DatabaseModels/MetricType";
-import BasicInfrastructureMetrics from "../../../Types/Infrastructure/BasicMetrics";
+import BasicInfrastructureMetrics, {
+  NetworkInterfaceMetrics,
+} from "../../../Types/Infrastructure/BasicMetrics";
 import Dictionary from "../../../Types/Dictionary";
 import { JSONObject } from "../../../Types/JSON";
 import CapturedMetric from "../../../Types/Monitor/CustomCodeMonitor/CapturedMetric";
@@ -159,6 +161,73 @@ export default class MonitorMetricUtil {
     } as JSONObject;
   }
 
+  /*
+   * Helper that collapses the "build attributes → build row → push → register MetricType"
+   * pattern used repeatedly below. Silently skips emission when value is missing/non-finite
+   * so callers can pass optional agent fields directly.
+   */
+  private static async pushMonitorMetric(data: {
+    projectId: ObjectID;
+    monitorId: ObjectID;
+    monitorName: string | undefined;
+    probeName: string | undefined;
+    metricName: string;
+    value: number | null | undefined;
+    description: string;
+    unit: string;
+    extraAttributes?: JSONObject;
+    metricPointType?: MetricPointType;
+    metricRows: Array<JSONObject>;
+    metricNameServiceNameMap: Dictionary<MetricType>;
+  }): Promise<void> {
+    if (
+      data.value === undefined ||
+      data.value === null ||
+      typeof data.value !== "number" ||
+      !isFinite(data.value)
+    ) {
+      return;
+    }
+
+    const attributeInput: {
+      monitorId: ObjectID;
+      projectId: ObjectID;
+      monitorName?: string | undefined;
+      probeName?: string | undefined;
+      extraAttributes?: JSONObject;
+    } = {
+      monitorId: data.monitorId,
+      projectId: data.projectId,
+      monitorName: data.monitorName,
+      probeName: data.probeName,
+    };
+
+    if (data.extraAttributes) {
+      attributeInput.extraAttributes = data.extraAttributes;
+    }
+
+    const attributes: JSONObject =
+      this.buildMonitorMetricAttributes(attributeInput);
+
+    const metricRow: JSONObject = await this.buildMonitorMetricRow({
+      projectId: data.projectId,
+      monitorId: data.monitorId,
+      metricName: data.metricName,
+      value: data.value,
+      attributes: attributes,
+      metricPointType: data.metricPointType || MetricPointType.Sum,
+    });
+
+    data.metricRows.push(metricRow);
+
+    const metricType: MetricType = new MetricType();
+    metricType.name = data.metricName;
+    metricType.description = data.description;
+    metricType.unit = data.unit;
+
+    data.metricNameServiceNameMap[data.metricName] = metricType;
+  }
+
   @CaptureSpan()
   public static async saveMonitorMetrics(data: {
     monitorId: ObjectID;
@@ -333,6 +402,359 @@ export default class MonitorMetricUtil {
           metricNameServiceNameMap[MonitorMetricType.DiskUsagePercent] =
             metricType;
         }
+
+        // Per-disk I/O counters (cumulative since boot).
+        for (const diskMetric of basicMetrics.diskMetrics) {
+          const diskAttrs: JSONObject = {};
+          if (diskMetric.diskPath) {
+            diskAttrs["diskPath"] = diskMetric.diskPath;
+          }
+          if (diskMetric.device) {
+            diskAttrs["device"] = diskMetric.device;
+          }
+          if (diskMetric.fstype) {
+            diskAttrs["fstype"] = diskMetric.fstype;
+          }
+
+          await this.pushMonitorMetric({
+            projectId: data.projectId,
+            monitorId: data.monitorId,
+            monitorName: data.monitorName,
+            probeName: data.probeName,
+            metricName: MonitorMetricType.DiskReadBytesTotal,
+            value: diskMetric.readBytes,
+            description: "Total bytes read from disk since boot",
+            unit: "bytes",
+            extraAttributes: diskAttrs,
+            metricRows,
+            metricNameServiceNameMap,
+          });
+
+          await this.pushMonitorMetric({
+            projectId: data.projectId,
+            monitorId: data.monitorId,
+            monitorName: data.monitorName,
+            probeName: data.probeName,
+            metricName: MonitorMetricType.DiskWriteBytesTotal,
+            value: diskMetric.writeBytes,
+            description: "Total bytes written to disk since boot",
+            unit: "bytes",
+            extraAttributes: diskAttrs,
+            metricRows,
+            metricNameServiceNameMap,
+          });
+
+          await this.pushMonitorMetric({
+            projectId: data.projectId,
+            monitorId: data.monitorId,
+            monitorName: data.monitorName,
+            probeName: data.probeName,
+            metricName: MonitorMetricType.DiskReadOpsTotal,
+            value: diskMetric.readCount,
+            description: "Total disk read operations since boot",
+            unit: "ops",
+            extraAttributes: diskAttrs,
+            metricRows,
+            metricNameServiceNameMap,
+          });
+
+          await this.pushMonitorMetric({
+            projectId: data.projectId,
+            monitorId: data.monitorId,
+            monitorName: data.monitorName,
+            probeName: data.probeName,
+            metricName: MonitorMetricType.DiskWriteOpsTotal,
+            value: diskMetric.writeCount,
+            description: "Total disk write operations since boot",
+            unit: "ops",
+            extraAttributes: diskAttrs,
+            metricRows,
+            metricNameServiceNameMap,
+          });
+        }
+      }
+
+      // Load average (1/5/15 min). Emitted only when the agent provides it.
+      if (basicMetrics.loadMetrics) {
+        await this.pushMonitorMetric({
+          projectId: data.projectId,
+          monitorId: data.monitorId,
+          monitorName: data.monitorName,
+          probeName: data.probeName,
+          metricName: MonitorMetricType.LoadAverage1Min,
+          value: basicMetrics.loadMetrics.load1,
+          description: "1-minute load average",
+          unit: "",
+          metricRows,
+          metricNameServiceNameMap,
+        });
+        await this.pushMonitorMetric({
+          projectId: data.projectId,
+          monitorId: data.monitorId,
+          monitorName: data.monitorName,
+          probeName: data.probeName,
+          metricName: MonitorMetricType.LoadAverage5Min,
+          value: basicMetrics.loadMetrics.load5,
+          description: "5-minute load average",
+          unit: "",
+          metricRows,
+          metricNameServiceNameMap,
+        });
+        await this.pushMonitorMetric({
+          projectId: data.projectId,
+          monitorId: data.monitorId,
+          monitorName: data.monitorName,
+          probeName: data.probeName,
+          metricName: MonitorMetricType.LoadAverage15Min,
+          value: basicMetrics.loadMetrics.load15,
+          description: "15-minute load average",
+          unit: "",
+          metricRows,
+          metricNameServiceNameMap,
+        });
+      }
+
+      // Memory extras: swap + available.
+      if (basicMetrics.memoryMetrics) {
+        await this.pushMonitorMetric({
+          projectId: data.projectId,
+          monitorId: data.monitorId,
+          monitorName: data.monitorName,
+          probeName: data.probeName,
+          metricName: MonitorMetricType.SwapUsagePercent,
+          value: basicMetrics.memoryMetrics.swapPercentUsed,
+          description: "Swap memory usage percentage",
+          unit: "%",
+          metricRows,
+          metricNameServiceNameMap,
+        });
+        await this.pushMonitorMetric({
+          projectId: data.projectId,
+          monitorId: data.monitorId,
+          monitorName: data.monitorName,
+          probeName: data.probeName,
+          metricName: MonitorMetricType.MemoryAvailableBytes,
+          value: basicMetrics.memoryMetrics.available,
+          description: "Memory available to new allocations",
+          unit: "bytes",
+          metricRows,
+          metricNameServiceNameMap,
+        });
+      }
+
+      // CPU time breakdown — drills down into what the CPU was doing.
+      if (basicMetrics.cpuMetrics) {
+        await this.pushMonitorMetric({
+          projectId: data.projectId,
+          monitorId: data.monitorId,
+          monitorName: data.monitorName,
+          probeName: data.probeName,
+          metricName: MonitorMetricType.CPUTimeUserPercent,
+          value: basicMetrics.cpuMetrics.timeUserPercent,
+          description: "CPU time spent in user space",
+          unit: "%",
+          metricRows,
+          metricNameServiceNameMap,
+        });
+        await this.pushMonitorMetric({
+          projectId: data.projectId,
+          monitorId: data.monitorId,
+          monitorName: data.monitorName,
+          probeName: data.probeName,
+          metricName: MonitorMetricType.CPUTimeSystemPercent,
+          value: basicMetrics.cpuMetrics.timeSystemPercent,
+          description: "CPU time spent in kernel space",
+          unit: "%",
+          metricRows,
+          metricNameServiceNameMap,
+        });
+        await this.pushMonitorMetric({
+          projectId: data.projectId,
+          monitorId: data.monitorId,
+          monitorName: data.monitorName,
+          probeName: data.probeName,
+          metricName: MonitorMetricType.CPUTimeIoWaitPercent,
+          value: basicMetrics.cpuMetrics.timeIoWaitPercent,
+          description: "CPU time spent waiting on I/O",
+          unit: "%",
+          metricRows,
+          metricNameServiceNameMap,
+        });
+        await this.pushMonitorMetric({
+          projectId: data.projectId,
+          monitorId: data.monitorId,
+          monitorName: data.monitorName,
+          probeName: data.probeName,
+          metricName: MonitorMetricType.CPUTimeIdlePercent,
+          value: basicMetrics.cpuMetrics.timeIdlePercent,
+          description: "CPU time spent idle",
+          unit: "%",
+          metricRows,
+          metricNameServiceNameMap,
+        });
+        await this.pushMonitorMetric({
+          projectId: data.projectId,
+          monitorId: data.monitorId,
+          monitorName: data.monitorName,
+          probeName: data.probeName,
+          metricName: MonitorMetricType.CPUTimeStealPercent,
+          value: basicMetrics.cpuMetrics.timeStealPercent,
+          description: "CPU time stolen by the hypervisor",
+          unit: "%",
+          metricRows,
+          metricNameServiceNameMap,
+        });
+      }
+
+      // Network counters — both per-interface and aggregate.
+      if (basicMetrics.networkMetrics) {
+        const net: typeof basicMetrics.networkMetrics =
+          basicMetrics.networkMetrics;
+
+        for (const iface of net.interfaces || []) {
+          const ifaceAttrs: JSONObject = {
+            interfaceName: (iface as NetworkInterfaceMetrics).interfaceName,
+          };
+
+          await this.pushMonitorMetric({
+            projectId: data.projectId,
+            monitorId: data.monitorId,
+            monitorName: data.monitorName,
+            probeName: data.probeName,
+            metricName: MonitorMetricType.NetworkBytesReceivedTotal,
+            value: iface.bytesReceived,
+            description: "Network bytes received since boot (per-interface)",
+            unit: "bytes",
+            extraAttributes: ifaceAttrs,
+            metricRows,
+            metricNameServiceNameMap,
+          });
+          await this.pushMonitorMetric({
+            projectId: data.projectId,
+            monitorId: data.monitorId,
+            monitorName: data.monitorName,
+            probeName: data.probeName,
+            metricName: MonitorMetricType.NetworkBytesSentTotal,
+            value: iface.bytesSent,
+            description: "Network bytes sent since boot (per-interface)",
+            unit: "bytes",
+            extraAttributes: ifaceAttrs,
+            metricRows,
+            metricNameServiceNameMap,
+          });
+          await this.pushMonitorMetric({
+            projectId: data.projectId,
+            monitorId: data.monitorId,
+            monitorName: data.monitorName,
+            probeName: data.probeName,
+            metricName: MonitorMetricType.NetworkPacketsReceivedTotal,
+            value: iface.packetsReceived,
+            description: "Network packets received since boot (per-interface)",
+            unit: "packets",
+            extraAttributes: ifaceAttrs,
+            metricRows,
+            metricNameServiceNameMap,
+          });
+          await this.pushMonitorMetric({
+            projectId: data.projectId,
+            monitorId: data.monitorId,
+            monitorName: data.monitorName,
+            probeName: data.probeName,
+            metricName: MonitorMetricType.NetworkPacketsSentTotal,
+            value: iface.packetsSent,
+            description: "Network packets sent since boot (per-interface)",
+            unit: "packets",
+            extraAttributes: ifaceAttrs,
+            metricRows,
+            metricNameServiceNameMap,
+          });
+          await this.pushMonitorMetric({
+            projectId: data.projectId,
+            monitorId: data.monitorId,
+            monitorName: data.monitorName,
+            probeName: data.probeName,
+            metricName: MonitorMetricType.NetworkErrorsIn,
+            value: iface.errorsIn,
+            description: "Network receive errors since boot (per-interface)",
+            unit: "errors",
+            extraAttributes: ifaceAttrs,
+            metricRows,
+            metricNameServiceNameMap,
+          });
+          await this.pushMonitorMetric({
+            projectId: data.projectId,
+            monitorId: data.monitorId,
+            monitorName: data.monitorName,
+            probeName: data.probeName,
+            metricName: MonitorMetricType.NetworkErrorsOut,
+            value: iface.errorsOut,
+            description: "Network transmit errors since boot (per-interface)",
+            unit: "errors",
+            extraAttributes: ifaceAttrs,
+            metricRows,
+            metricNameServiceNameMap,
+          });
+        }
+
+        await this.pushMonitorMetric({
+          projectId: data.projectId,
+          monitorId: data.monitorId,
+          monitorName: data.monitorName,
+          probeName: data.probeName,
+          metricName: MonitorMetricType.NetworkConnectionsEstablished,
+          value: net.connectionsEstablished,
+          description: "Count of ESTABLISHED network connections",
+          unit: "connections",
+          metricRows,
+          metricNameServiceNameMap,
+        });
+        await this.pushMonitorMetric({
+          projectId: data.projectId,
+          monitorId: data.monitorId,
+          monitorName: data.monitorName,
+          probeName: data.probeName,
+          metricName: MonitorMetricType.NetworkConnectionsListen,
+          value: net.connectionsListen,
+          description: "Count of LISTENing network sockets",
+          unit: "connections",
+          metricRows,
+          metricNameServiceNameMap,
+        });
+      }
+
+      // Host uptime.
+      if (basicMetrics.hostMetrics) {
+        await this.pushMonitorMetric({
+          projectId: data.projectId,
+          monitorId: data.monitorId,
+          monitorName: data.monitorName,
+          probeName: data.probeName,
+          metricName: MonitorMetricType.HostUptimeSeconds,
+          value: basicMetrics.hostMetrics.uptimeSeconds,
+          description: "Host uptime in seconds",
+          unit: "seconds",
+          metricRows,
+          metricNameServiceNameMap,
+        });
+      }
+
+      // Process count — simple scalar derived from the processes array.
+      const serverProcesses: Array<unknown> | undefined = (
+        data.dataToProcess as ServerMonitorResponse
+      ).processes;
+      if (serverProcesses && serverProcesses.length >= 0) {
+        await this.pushMonitorMetric({
+          projectId: data.projectId,
+          monitorId: data.monitorId,
+          monitorName: data.monitorName,
+          probeName: data.probeName,
+          metricName: MonitorMetricType.ProcessCountTotal,
+          value: serverProcesses.length,
+          description: "Total running processes on the server",
+          unit: "processes",
+          metricRows,
+          metricNameServiceNameMap,
+        });
       }
     }
 

package/Server/Utils/Monitor/MonitorResource.ts

@@ -709,6 +709,7 @@ export default class MonitorResourceUtil {
         props: {
           telemetryQuery: telemetryQuery,
         },
+        matchesPerSeries: response.perSeriesMatches,
       });
 
       await MonitorAlert.criteriaMetCreateAlertsAndUpdateMonitorStatus({
@@ -721,6 +722,7 @@ export default class MonitorResourceUtil {
         props: {
           telemetryQuery: telemetryQuery,
         },
+        matchesPerSeries: response.perSeriesMatches,
       });
     } else if (
       !response.criteriaMetId &&