@oneuptime/common 10.0.71 → 10.0.72

package/Server/Utils/Monitor/MonitorTemplateUtil.ts

@@ -1,4 +1,5 @@
 import MonitorType from "../../../Types/Monitor/MonitorType";
+import Monitor from "../../../Models/DatabaseModels/Monitor";
 import { JSONObject } from "../../../Types/JSON";
 import ProbeMonitorResponse from "../../../Types/Probe/ProbeMonitorResponse";
 import IncomingMonitorRequest from "../../../Types/Monitor/IncomingMonitor/IncomingMonitorRequest";
@@ -21,6 +22,7 @@ import DomainMonitorResponse from "../../../Types/Monitor/DomainMonitor/DomainMo
 import ExternalStatusPageMonitorResponse, {
   ExternalStatusPageComponentStatus,
 } from "../../../Types/Monitor/ExternalStatusPageMonitor/ExternalStatusPageMonitorResponse";
+import MetricMonitorResponse from "../../../Types/Monitor/MetricMonitor/MetricMonitorResponse";
 import Typeof from "../../../Types/Typeof";
 import VMUtil from "../VM/VMAPI";
 import DataToProcess from "./DataToProcess";
@@ -37,6 +39,21 @@ export default class MonitorTemplateUtil {
   public static buildTemplateStorageMap(data: {
     monitorType: MonitorType;
     dataToProcess: DataToProcess;
+    /**
+     * The monitor that fired this criterion. Used to expose identity
+     * fields (`{{monitorName}}`, `{{monitorId}}`, etc.) to incident
+     * and alert title/description templates. Optional for backwards
+     * compatibility with existing callers.
+     */
+    monitor?: Monitor | undefined;
+    /**
+     * When set, the attribute values identifying the specific series
+     * this template is being rendered for. Each label is exposed to
+     * the template under its own key (so `{{host.name}}` works) and
+     * also collected under a `seriesLabels` object for iteration.
+     * Only populated when a metric monitor fires per-series.
+     */
+    seriesLabels?: JSONObject | undefined;
   }): JSONObject {
     let storageMap: JSONObject = {};
 
@@ -315,6 +332,31 @@ export default class MonitorTemplateUtil {
         } as JSONObject;
       }
 
+      if (
+        data.monitorType === MonitorType.Metrics ||
+        data.monitorType === MonitorType.Kubernetes ||
+        data.monitorType === MonitorType.Docker
+      ) {
+        const metricResponse: MetricMonitorResponse =
+          data.dataToProcess as MetricMonitorResponse;
+
+        const queryConfigs: Array<unknown> =
+          metricResponse.metricViewConfig?.queryConfigs || [];
+
+        const firstQuery: unknown = queryConfigs[0];
+        const metricName: string | undefined = (
+          firstQuery as
+            | {
+                metricQueryData?: { filterData?: { metricName?: string } };
+              }
+            | undefined
+        )?.metricQueryData?.filterData?.metricName;
+
+        storageMap = {
+          metricName: metricName || "",
+        } as JSONObject;
+      }
+
       if (data.monitorType === MonitorType.ExternalStatusPage) {
         const externalStatusPageResponse:
           | ExternalStatusPageMonitorResponse
@@ -347,6 +389,63 @@ export default class MonitorTemplateUtil {
       logger.error(err);
     }
 
+    /*
+     * Fold series labels onto the storage map so templates like
+     * `{{host.name}}` or `{{resource.k8s.container.name}}` resolve at
+     * render time. The template engine walks dotted paths as nested
+     * property access (`host` → `.name`), so for each dotted label
+     * key we build up a nested object rather than storing the flat
+     * key. Also expose the full label map under `seriesLabels` for
+     * iteration-style templates.
+     */
+    if (data.seriesLabels && Object.keys(data.seriesLabels).length > 0) {
+      for (const key of Object.keys(data.seriesLabels)) {
+        const value: unknown = data.seriesLabels[key];
+        if (value === undefined || value === null) {
+          continue;
+        }
+        const parts: Array<string> = key.split(".");
+        let cursor: JSONObject = storageMap;
+        for (let i: number = 0; i < parts.length - 1; i++) {
+          const part: string = parts[i]!;
+          const existing: unknown = cursor[part];
+          if (
+            !existing ||
+            typeof existing !== "object" ||
+            Array.isArray(existing)
+          ) {
+            cursor[part] = {};
+          }
+          cursor = cursor[part] as JSONObject;
+        }
+        cursor[parts[parts.length - 1]!] = value as JSONObject[string];
+      }
+      storageMap["seriesLabels"] = data.seriesLabels;
+    }
+
+    /*
+     * Monitor identity fields. Always exposed (when a monitor is provided),
+     * independent of monitorType, so templates like `{{monitorName}}` work
+     * uniformly across Server/VM, Probe, Synthetic, Metric monitors, etc.
+     */
+    if (data.monitor) {
+      if (data.monitor.name) {
+        storageMap["monitorName"] = data.monitor.name;
+      }
+      if (data.monitor.id) {
+        storageMap["monitorId"] = data.monitor.id.toString();
+      }
+      if (data.monitor.description) {
+        storageMap["monitorDescription"] = data.monitor.description;
+      }
+      if (data.monitor.slug) {
+        storageMap["monitorSlug"] = data.monitor.slug;
+      }
+      if (data.monitor.monitorType) {
+        storageMap["monitorType"] = data.monitor.monitorType;
+      }
+    }
+
     logger.debug(`Storage Map: ${JSON.stringify(storageMap, null, 2)}`);
 
     return storageMap;

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/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 {