@oneuptime/common 10.0.71 → 10.0.73

package/Utils/Metrics/MetricSeriesFingerprint.ts

@@ -0,0 +1,97 @@
+import { createHash } from "crypto";
+import AggregatedModel from "../../Types/BaseDatabase/AggregatedModel";
+import { JSONObject, JSONValue } from "../../Types/JSON";
+
+/**
+ * Canonicalize a label dictionary (key/value string pairs identifying a
+ * metric series) into a stable short hash. Used to key incidents/alerts
+ * by the series that breached so one incident is created per host (or
+ * per whatever attribute combination the user grouped by) rather than a
+ * single incident per monitor.
+ */
+export default class MetricSeriesFingerprint {
+  /**
+   * Sentinel fingerprint used when a metric monitor has no group-by
+   * configured — i.e. traditional whole-monitor evaluation. Using an
+   * explicit sentinel (rather than undefined) lets callers store a
+   * single value and still use the same dedupe query shape.
+   */
+  public static readonly WholeMonitorFingerprint: string = "__all__";
+
+  /**
+   * Compute a deterministic 16-char hex fingerprint from a label map.
+   * Keys are sorted so `{a,b}` and `{b,a}` hash identically. Null and
+   * undefined values canonicalize to the empty string so a series that
+   * occasionally drops an attribute still maps to the same bucket.
+   */
+  public static computeFingerprint(labels: JSONObject): string {
+    const keys: Array<string> = Object.keys(labels || {}).sort();
+
+    if (keys.length === 0) {
+      return MetricSeriesFingerprint.WholeMonitorFingerprint;
+    }
+
+    const parts: Array<string> = [];
+
+    for (const key of keys) {
+      const raw: JSONValue | undefined = labels[key];
+      const value: string =
+        raw === undefined || raw === null ? "" : String(raw);
+      parts.push(`${key}=${value}`);
+    }
+
+    return createHash("sha256")
+      .update(parts.join("|"))
+      .digest("hex")
+      .slice(0, 16);
+  }
+
+  /**
+   * Extract the series labels from an aggregated sample. When
+   * `attributeKeys` is provided, pulls those specific keys out of the
+   * sample's `attributes` map (OpenTelemetry attributes live nested in
+   * a MapStringString column, so users group by "host.name" as an
+   * attribute KEY rather than a top-level column). When no keys are
+   * provided, falls back to every non-reserved key on the sample so
+   * callers that pass top-level group-by columns still work.
+   */
+  public static extractSeriesLabels(input: {
+    sample: AggregatedModel;
+    attributeKeys?: Array<string> | undefined;
+  }): JSONObject {
+    const result: JSONObject = {};
+
+    const sampleAttributes: JSONObject =
+      ((input.sample as unknown as JSONObject)["attributes"] as
+        | JSONObject
+        | undefined) || {};
+
+    if (input.attributeKeys && input.attributeKeys.length > 0) {
+      for (const key of input.attributeKeys) {
+        const value: JSONValue | undefined = sampleAttributes[key];
+        if (value !== undefined && value !== null) {
+          result[key] = value;
+        } else {
+          /*
+           * Preserve the key even when missing so the fingerprint stays
+           * stable across evaluations that happen to drop the attribute.
+           */
+          result[key] = "";
+        }
+      }
+      return result;
+    }
+
+    for (const key of Object.keys(input.sample)) {
+      if (key === "timestamp" || key === "value") {
+        continue;
+      }
+      const value: unknown = (input.sample as unknown as JSONObject)[key];
+      if (value === undefined || value === null) {
+        continue;
+      }
+      result[key] = value as JSONValue;
+    }
+    return result;
+  }
+}

package/Utils/Monitor/MonitorMetricType.ts

@@ -3,6 +3,17 @@ import { CheckOn } from "../../Types/Monitor/CriteriaFilter";
 import MonitorMetricType from "../../Types/Monitor/MonitorMetricType";
 import MonitorType from "../../Types/Monitor/MonitorType";
 
+/*
+ * Groups of metrics rendered as separate cards on the monitor metrics page.
+ * Keeps the Server/VM page navigable — CPU / Memory / Disk / Network each
+ * get their own card rather than one 28-chart scroll.
+ */
+export interface MonitorMetricCategory {
+  title: string;
+  description: string;
+  metrics: Array<MonitorMetricType>;
+}
+
 class MonitorMetricTypeUtil {
   public static getAggregationTypeByMonitorMetricType(
     monitorMetricType: MonitorMetricType,
@@ -22,6 +33,41 @@ class MonitorMetricTypeUtil {
         return AggregationType.Avg;
       case MonitorMetricType.ExecutionTime:
         return AggregationType.Avg;
+
+      /*
+       * Extended server/VM metrics. Cumulative counters (bytes/packets/ops since
+       * boot) use Max so the latest value in a time bucket is returned, which the
+       * chart/UI can turn into a rate by differencing adjacent buckets. Gauges
+       * (percentages, counts, load averages) use Avg.
+       */
+      case MonitorMetricType.LoadAverage1Min:
+      case MonitorMetricType.LoadAverage5Min:
+      case MonitorMetricType.LoadAverage15Min:
+      case MonitorMetricType.SwapUsagePercent:
+      case MonitorMetricType.MemoryAvailableBytes:
+      case MonitorMetricType.CPUTimeUserPercent:
+      case MonitorMetricType.CPUTimeSystemPercent:
+      case MonitorMetricType.CPUTimeIoWaitPercent:
+      case MonitorMetricType.CPUTimeIdlePercent:
+      case MonitorMetricType.CPUTimeStealPercent:
+      case MonitorMetricType.NetworkConnectionsEstablished:
+      case MonitorMetricType.NetworkConnectionsListen:
+      case MonitorMetricType.ProcessCountTotal:
+        return AggregationType.Avg;
+
+      case MonitorMetricType.DiskReadBytesTotal:
+      case MonitorMetricType.DiskWriteBytesTotal:
+      case MonitorMetricType.DiskReadOpsTotal:
+      case MonitorMetricType.DiskWriteOpsTotal:
+      case MonitorMetricType.NetworkBytesReceivedTotal:
+      case MonitorMetricType.NetworkBytesSentTotal:
+      case MonitorMetricType.NetworkPacketsReceivedTotal:
+      case MonitorMetricType.NetworkPacketsSentTotal:
+      case MonitorMetricType.NetworkErrorsIn:
+      case MonitorMetricType.NetworkErrorsOut:
+      case MonitorMetricType.HostUptimeSeconds:
+        return AggregationType.Max;
+
       default:
         throw new Error("Invalid MonitorMetricType value");
     }
@@ -45,6 +91,16 @@ class MonitorMetricTypeUtil {
         return MonitorMetricType.MemoryUsagePercent;
       case CheckOn.ExecutionTime:
         return MonitorMetricType.ExecutionTime;
+      case CheckOn.LoadAverage1Min:
+        return MonitorMetricType.LoadAverage1Min;
+      case CheckOn.LoadAverage5Min:
+        return MonitorMetricType.LoadAverage5Min;
+      case CheckOn.LoadAverage15Min:
+        return MonitorMetricType.LoadAverage15Min;
+      case CheckOn.SwapUsagePercent:
+        return MonitorMetricType.SwapUsagePercent;
+      case CheckOn.CPUIoWaitPercent:
+        return MonitorMetricType.CPUTimeIoWaitPercent;
       default:
         throw new Error("Invalid CheckOn value");
     }
@@ -65,11 +121,39 @@ class MonitorMetricTypeUtil {
     }
 
     if (monitorType === MonitorType.Server) {
+      /*
+       * Order below reflects the chart display order on the monitor view.
+       * Core resource gauges first, then I/O counters, then diagnostics.
+       */
       return [
         MonitorMetricType.IsOnline,
-        MonitorMetricType.DiskUsagePercent,
         MonitorMetricType.CPUUsagePercent,
         MonitorMetricType.MemoryUsagePercent,
+        MonitorMetricType.DiskUsagePercent,
+        MonitorMetricType.LoadAverage1Min,
+        MonitorMetricType.LoadAverage5Min,
+        MonitorMetricType.LoadAverage15Min,
+        MonitorMetricType.SwapUsagePercent,
+        MonitorMetricType.MemoryAvailableBytes,
+        MonitorMetricType.CPUTimeUserPercent,
+        MonitorMetricType.CPUTimeSystemPercent,
+        MonitorMetricType.CPUTimeIoWaitPercent,
+        MonitorMetricType.CPUTimeIdlePercent,
+        MonitorMetricType.CPUTimeStealPercent,
+        MonitorMetricType.DiskReadBytesTotal,
+        MonitorMetricType.DiskWriteBytesTotal,
+        MonitorMetricType.DiskReadOpsTotal,
+        MonitorMetricType.DiskWriteOpsTotal,
+        MonitorMetricType.NetworkBytesReceivedTotal,
+        MonitorMetricType.NetworkBytesSentTotal,
+        MonitorMetricType.NetworkPacketsReceivedTotal,
+        MonitorMetricType.NetworkPacketsSentTotal,
+        MonitorMetricType.NetworkErrorsIn,
+        MonitorMetricType.NetworkErrorsOut,
+        MonitorMetricType.NetworkConnectionsEstablished,
+        MonitorMetricType.NetworkConnectionsListen,
+        MonitorMetricType.ProcessCountTotal,
+        MonitorMetricType.HostUptimeSeconds,
       ];
     }
 
@@ -96,6 +180,95 @@ class MonitorMetricTypeUtil {
     return [];
   }
 
+  /*
+   * Returns the metrics grouped into display categories. Server monitors get
+   * a rich 5-card layout; every other monitor type falls through to a single
+   * "Monitor Metrics" category so existing pages look unchanged.
+   */
+  public static getMonitorMetricCategoriesByMonitorType(
+    monitorType: MonitorType,
+  ): Array<MonitorMetricCategory> {
+    if (monitorType === MonitorType.Server) {
+      return [
+        {
+          title: "Availability",
+          description:
+            "Heartbeat, uptime, and process count reported by the agent.",
+          metrics: [
+            MonitorMetricType.IsOnline,
+            MonitorMetricType.HostUptimeSeconds,
+            MonitorMetricType.ProcessCountTotal,
+          ],
+        },
+        {
+          title: "CPU",
+          description:
+            "CPU utilisation, load averages, and time-spent breakdown.",
+          metrics: [
+            MonitorMetricType.CPUUsagePercent,
+            MonitorMetricType.LoadAverage1Min,
+            MonitorMetricType.LoadAverage5Min,
+            MonitorMetricType.LoadAverage15Min,
+            MonitorMetricType.CPUTimeUserPercent,
+            MonitorMetricType.CPUTimeSystemPercent,
+            MonitorMetricType.CPUTimeIoWaitPercent,
+            MonitorMetricType.CPUTimeIdlePercent,
+            MonitorMetricType.CPUTimeStealPercent,
+          ],
+        },
+        {
+          title: "Memory",
+          description: "RAM usage, swap pressure, and bytes still available.",
+          metrics: [
+            MonitorMetricType.MemoryUsagePercent,
+            MonitorMetricType.SwapUsagePercent,
+            MonitorMetricType.MemoryAvailableBytes,
+          ],
+        },
+        {
+          title: "Disk",
+          description: "Space usage and I/O throughput per partition.",
+          metrics: [
+            MonitorMetricType.DiskUsagePercent,
+            MonitorMetricType.DiskReadBytesTotal,
+            MonitorMetricType.DiskWriteBytesTotal,
+            MonitorMetricType.DiskReadOpsTotal,
+            MonitorMetricType.DiskWriteOpsTotal,
+          ],
+        },
+        {
+          title: "Network",
+          description:
+            "Per-interface throughput, packet errors, and connection counts.",
+          metrics: [
+            MonitorMetricType.NetworkBytesReceivedTotal,
+            MonitorMetricType.NetworkBytesSentTotal,
+            MonitorMetricType.NetworkPacketsReceivedTotal,
+            MonitorMetricType.NetworkPacketsSentTotal,
+            MonitorMetricType.NetworkErrorsIn,
+            MonitorMetricType.NetworkErrorsOut,
+            MonitorMetricType.NetworkConnectionsEstablished,
+            MonitorMetricType.NetworkConnectionsListen,
+          ],
+        },
+      ];
+    }
+
+    // Other monitor types keep the single-card layout.
+    const metrics: Array<MonitorMetricType> =
+      this.getMonitorMetricTypesByMonitorType(monitorType);
+    if (metrics.length === 0) {
+      return [];
+    }
+    return [
+      {
+        title: "Monitor Metrics",
+        description: "Performance metrics collected from this monitor.",
+        metrics: metrics,
+      },
+    ];
+  }
+
   public static getTitleByMonitorMetricType(
     monitorMetricType: MonitorMetricType,
   ): string {
@@ -114,6 +287,54 @@ class MonitorMetricTypeUtil {
         return "Memory Usage Percent";
       case MonitorMetricType.ExecutionTime:
         return "Execution Time";
+      case MonitorMetricType.LoadAverage1Min:
+        return "Load Average (1 minute)";
+      case MonitorMetricType.LoadAverage5Min:
+        return "Load Average (5 minute)";
+      case MonitorMetricType.LoadAverage15Min:
+        return "Load Average (15 minute)";
+      case MonitorMetricType.SwapUsagePercent:
+        return "Swap Usage Percent";
+      case MonitorMetricType.MemoryAvailableBytes:
+        return "Memory Available";
+      case MonitorMetricType.CPUTimeUserPercent:
+        return "CPU Time - User";
+      case MonitorMetricType.CPUTimeSystemPercent:
+        return "CPU Time - System";
+      case MonitorMetricType.CPUTimeIoWaitPercent:
+        return "CPU Time - IO Wait";
+      case MonitorMetricType.CPUTimeIdlePercent:
+        return "CPU Time - Idle";
+      case MonitorMetricType.CPUTimeStealPercent:
+        return "CPU Time - Steal";
+      case MonitorMetricType.DiskReadBytesTotal:
+        return "Disk Read Bytes (cumulative)";
+      case MonitorMetricType.DiskWriteBytesTotal:
+        return "Disk Write Bytes (cumulative)";
+      case MonitorMetricType.DiskReadOpsTotal:
+        return "Disk Read Ops (cumulative)";
+      case MonitorMetricType.DiskWriteOpsTotal:
+        return "Disk Write Ops (cumulative)";
+      case MonitorMetricType.NetworkBytesReceivedTotal:
+        return "Network Bytes Received (cumulative)";
+      case MonitorMetricType.NetworkBytesSentTotal:
+        return "Network Bytes Sent (cumulative)";
+      case MonitorMetricType.NetworkPacketsReceivedTotal:
+        return "Network Packets Received (cumulative)";
+      case MonitorMetricType.NetworkPacketsSentTotal:
+        return "Network Packets Sent (cumulative)";
+      case MonitorMetricType.NetworkErrorsIn:
+        return "Network Receive Errors";
+      case MonitorMetricType.NetworkErrorsOut:
+        return "Network Transmit Errors";
+      case MonitorMetricType.NetworkConnectionsEstablished:
+        return "Network Connections - Established";
+      case MonitorMetricType.NetworkConnectionsListen:
+        return "Network Connections - Listening";
+      case MonitorMetricType.HostUptimeSeconds:
+        return "Host Uptime";
+      case MonitorMetricType.ProcessCountTotal:
+        return "Running Processes";
       default:
         return "";
     }
@@ -122,24 +343,12 @@ class MonitorMetricTypeUtil {
   public static getLegendByMonitorMetricType(
     monitorMetricType: MonitorMetricType,
   ): string {
-    switch (monitorMetricType) {
-      case MonitorMetricType.ResponseTime:
-        return "Response Time";
-      case MonitorMetricType.ResponseStatusCode:
-        return "Response Status Code";
-      case MonitorMetricType.IsOnline:
-        return "Is Online";
-      case MonitorMetricType.DiskUsagePercent:
-        return "Disk Usage Percent";
-      case MonitorMetricType.CPUUsagePercent:
-        return "CPU Usage Percent";
-      case MonitorMetricType.MemoryUsagePercent:
-        return "Memory Usage Percent";
-      case MonitorMetricType.ExecutionTime:
-        return "Execution Time";
-      default:
-        return "";
-    }
+    /*
+     * Legend labels default to the title, which also matches the existing behavior
+     * for every metric type. Keeping this as a separate function preserves the
+     * option to diverge later (e.g. shorter legend labels for dense charts).
+     */
+    return this.getTitleByMonitorMetricType(monitorMetricType);
   }
 
   public static getLegendUnitByMonitorMetricType(
@@ -160,6 +369,39 @@ class MonitorMetricTypeUtil {
         return "%";
       case MonitorMetricType.ExecutionTime:
         return "ms";
+      case MonitorMetricType.LoadAverage1Min:
+      case MonitorMetricType.LoadAverage5Min:
+      case MonitorMetricType.LoadAverage15Min:
+        return "";
+      case MonitorMetricType.SwapUsagePercent:
+      case MonitorMetricType.CPUTimeUserPercent:
+      case MonitorMetricType.CPUTimeSystemPercent:
+      case MonitorMetricType.CPUTimeIoWaitPercent:
+      case MonitorMetricType.CPUTimeIdlePercent:
+      case MonitorMetricType.CPUTimeStealPercent:
+        return "%";
+      case MonitorMetricType.MemoryAvailableBytes:
+      case MonitorMetricType.DiskReadBytesTotal:
+      case MonitorMetricType.DiskWriteBytesTotal:
+      case MonitorMetricType.NetworkBytesReceivedTotal:
+      case MonitorMetricType.NetworkBytesSentTotal:
+        return "bytes";
+      case MonitorMetricType.DiskReadOpsTotal:
+      case MonitorMetricType.DiskWriteOpsTotal:
+        return "ops";
+      case MonitorMetricType.NetworkPacketsReceivedTotal:
+      case MonitorMetricType.NetworkPacketsSentTotal:
+        return "packets";
+      case MonitorMetricType.NetworkErrorsIn:
+      case MonitorMetricType.NetworkErrorsOut:
+        return "errors";
+      case MonitorMetricType.NetworkConnectionsEstablished:
+      case MonitorMetricType.NetworkConnectionsListen:
+        return "connections";
+      case MonitorMetricType.HostUptimeSeconds:
+        return "seconds";
+      case MonitorMetricType.ProcessCountTotal:
+        return "processes";
       default:
         return "";
     }
@@ -183,6 +425,54 @@ class MonitorMetricTypeUtil {
         return "Memory usage percent is the percentage of memory that is currently being used on a server. It is a measure of how much of the server's memory is being used.";
       case MonitorMetricType.ExecutionTime:
         return "Execution time is the time taken for a custom JavaScript code or a synthetic monitor to execute.";
+      case MonitorMetricType.LoadAverage1Min:
+        return "Average number of runnable or uninterruptible processes over the last 1 minute. Values persistently above the number of CPU cores indicate CPU saturation.";
+      case MonitorMetricType.LoadAverage5Min:
+        return "Average number of runnable or uninterruptible processes over the last 5 minutes.";
+      case MonitorMetricType.LoadAverage15Min:
+        return "Average number of runnable or uninterruptible processes over the last 15 minutes — the most stable load indicator.";
+      case MonitorMetricType.SwapUsagePercent:
+        return "Percentage of swap space in use. Sustained non-zero values typically indicate memory pressure.";
+      case MonitorMetricType.MemoryAvailableBytes:
+        return "Estimated bytes of memory available for allocating to new processes without swapping.";
+      case MonitorMetricType.CPUTimeUserPercent:
+        return "Percentage of CPU time spent executing user-space processes.";
+      case MonitorMetricType.CPUTimeSystemPercent:
+        return "Percentage of CPU time spent executing kernel-space code (system calls, interrupts).";
+      case MonitorMetricType.CPUTimeIoWaitPercent:
+        return "Percentage of CPU time spent waiting on disk I/O. High iowait often indicates a storage bottleneck.";
+      case MonitorMetricType.CPUTimeIdlePercent:
+        return "Percentage of CPU time spent idle (not executing any work).";
+      case MonitorMetricType.CPUTimeStealPercent:
+        return "Percentage of CPU time the hypervisor stole from this VM to service other guests. Only relevant on virtualized hosts.";
+      case MonitorMetricType.DiskReadBytesTotal:
+        return "Cumulative bytes read from each disk since boot. Take a derivative over time to get read throughput.";
+      case MonitorMetricType.DiskWriteBytesTotal:
+        return "Cumulative bytes written to each disk since boot. Take a derivative over time to get write throughput.";
+      case MonitorMetricType.DiskReadOpsTotal:
+        return "Cumulative disk read operations since boot, per disk.";
+      case MonitorMetricType.DiskWriteOpsTotal:
+        return "Cumulative disk write operations since boot, per disk.";
+      case MonitorMetricType.NetworkBytesReceivedTotal:
+        return "Cumulative bytes received on each network interface since boot. Derivative over time yields receive throughput.";
+      case MonitorMetricType.NetworkBytesSentTotal:
+        return "Cumulative bytes transmitted on each network interface since boot. Derivative over time yields send throughput.";
+      case MonitorMetricType.NetworkPacketsReceivedTotal:
+        return "Cumulative packets received per interface since boot.";
+      case MonitorMetricType.NetworkPacketsSentTotal:
+        return "Cumulative packets transmitted per interface since boot.";
+      case MonitorMetricType.NetworkErrorsIn:
+        return "Cumulative receive errors per interface. Increases typically point to cabling, NIC, or driver issues.";
+      case MonitorMetricType.NetworkErrorsOut:
+        return "Cumulative transmit errors per interface.";
+      case MonitorMetricType.NetworkConnectionsEstablished:
+        return "Count of network connections currently in ESTABLISHED state.";
+      case MonitorMetricType.NetworkConnectionsListen:
+        return "Count of sockets currently in LISTEN state — one per service accepting connections.";
+      case MonitorMetricType.HostUptimeSeconds:
+        return "Seconds since the host was last booted.";
+      case MonitorMetricType.ProcessCountTotal:
+        return "Number of running processes reported by the agent.";
       default:
         return "";
     }

package/build/dist/Models/DatabaseModels/Alert.js

@@ -65,6 +65,8 @@ let Alert = class Alert extends BaseModel {
         this.rootCause = undefined;
         this.createdStateLog = undefined;
         this.createdCriteriaId = undefined;
+        this.seriesFingerprint = undefined;
+        this.seriesLabels = undefined;
         this.createdByProbe = undefined;
         this.createdByProbeId = undefined;
         this.isCreatedAutomatically = undefined;
@@ -933,6 +935,61 @@ __decorate([
     }),
     __metadata("design:type", String)
 ], Alert.prototype, "createdCriteriaId", void 0);
+__decorate([
+    ColumnAccessControl({
+        create: [],
+        read: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.ProjectMember,
+            Permission.Viewer,
+            Permission.AlertManager,
+            Permission.ReadAlert,
+            Permission.ReadAllProjectResources,
+        ],
+        update: [],
+    }),
+    Index(),
+    TableColumn({
+        type: TableColumnType.LongText,
+        required: false,
+        isDefaultValueColumn: false,
+        title: "Series Fingerprint",
+        description: "For metric monitors with per-series alerting (e.g. grouped by host.name), this is a stable hash of the series label values so one alert is created per affected series.",
+    }),
+    Column({
+        type: ColumnType.LongText,
+        nullable: true,
+    }),
+    __metadata("design:type", String)
+], Alert.prototype, "seriesFingerprint", void 0);
+__decorate([
+    ColumnAccessControl({
+        create: [],
+        read: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.ProjectMember,
+            Permission.Viewer,
+            Permission.AlertManager,
+            Permission.ReadAlert,
+            Permission.ReadAllProjectResources,
+        ],
+        update: [],
+    }),
+    TableColumn({
+        type: TableColumnType.JSON,
+        required: false,
+        isDefaultValueColumn: false,
+        title: "Series Labels",
+        description: "Attribute key/value pairs that identify the affected series (e.g. {host.name: prod-db-01}) when this alert was created from a per-series metric breach.",
+    }),
+    Column({
+        type: ColumnType.JSON,
+        nullable: true,
+    }),
+    __metadata("design:type", Object)
+], Alert.prototype, "seriesLabels", void 0);
 __decorate([
     ColumnAccessControl({
         create: [],