@oneuptime/common 10.5.29 → 10.5.31

package/Server/Services/UserNotificationRuleService.ts

@@ -1838,7 +1838,7 @@ export class Service extends DatabaseService<Model> {
       to: to,
       data: [
         {
-          sayMessage: "This is a call from OneUptime",
+          sayMessage: "This is a call from One Uptime",
         },
         {
           sayMessage: "A new alert has been created",
@@ -1894,7 +1894,7 @@ export class Service extends DatabaseService<Model> {
       to: to,
       data: [
         {
-          sayMessage: "This is a call from OneUptime",
+          sayMessage: "This is a call from One Uptime",
         },
         {
           sayMessage: "A new incident has been created",
@@ -1951,7 +1951,7 @@ export class Service extends DatabaseService<Model> {
       to: to,
       data: [
         {
-          sayMessage: "This is a call from OneUptime",
+          sayMessage: "This is a call from One Uptime",
         },
         {
           sayMessage: "A new alert episode has been created",

package/Types/Dashboard/DashboardTemplates.ts

@@ -933,12 +933,13 @@ function createKubernetesDashboardConfig(): DashboardViewConfig {
    *   first-class percent metric we replace it with a Value widget that
    *   renders the absolute usage via ValueFormatter (e.g. "8.3 GB").
    *
-   * - CPU widgets use OTel's k8s.*.cpu.utilization, which the collector
-   *   emits as a [0, 1] ratio with unit "1". DashboardValueComponent /
-   *   DashboardGaugeComponent now scale that to a percent at render time
-   *   when the metric name carries the `.utilization` suffix, so "0.05"
-   *   reads as "5.00%" and gauge thresholds in the natural 0-100 scale work
-   *   as expected.
+   * - CPU widgets show cores, not a percent. OTel's k8s.*.cpu.utilization
+   *   is a misnamed cores gauge (cores in use, NOT a [0, 1] ratio), and
+   *   this templated dashboard's renderer can't divide by per-node
+   *   allocatable CPU to form a true percentage. So we use the `.usage`
+   *   metrics and label them in cores ("2.3 cores"). The Kubernetes
+   *   cluster overview page — which fetches `k8s.node.allocatable_cpu` —
+   *   is where CPU is shown as a real "% of capacity".
    */
   const components: Array<DashboardBaseComponent> = [
     // Row 0: Title
@@ -953,16 +954,16 @@ function createKubernetesDashboardConfig(): DashboardViewConfig {
 
     /*
      * Row 1: Key cluster metrics — averages render with proper units via
-     * ValueFormatter (CPU utilization → "%", memory.usage → "MB"/"GB").
+     * ValueFormatter (CPU usage → cores, memory.usage → "MB"/"GB").
      * All four are "higher = worse" (closer to capacity = bad).
      */
     createValueComponent({
-      title: "Pod CPU (avg)",
+      title: "Pod CPU (cores, avg)",
       top: 1,
       left: 0,
       width: 3,
       metricConfig: {
-        metricName: "k8s.pod.cpu.utilization",
+        metricName: "k8s.pod.cpu.usage",
         aggregationType: MetricsAggregationType.Avg,
       },
       trendDirection: DashboardValueTrendDirection.HigherIsWorse,
@@ -979,12 +980,12 @@ function createKubernetesDashboardConfig(): DashboardViewConfig {
       trendDirection: DashboardValueTrendDirection.HigherIsWorse,
     }),
     createValueComponent({
-      title: "Node CPU (avg)",
+      title: "Node CPU (cores, avg)",
       top: 1,
       left: 6,
       width: 3,
       metricConfig: {
-        metricName: "k8s.node.cpu.utilization",
+        metricName: "k8s.node.cpu.usage",
         aggregationType: MetricsAggregationType.Avg,
       },
       trendDirection: DashboardValueTrendDirection.HigherIsWorse,
@@ -1003,16 +1004,16 @@ function createKubernetesDashboardConfig(): DashboardViewConfig {
 
     // Row 2-4: Resource usage charts
     createChartComponent({
-      title: "CPU Usage Over Time",
+      title: "Pod CPU Cores Over Time",
       chartType: DashboardChartType.Line,
       top: 2,
       left: 0,
       width: 6,
       height: 3,
       metricConfig: {
-        metricName: "k8s.pod.cpu.utilization",
+        metricName: "k8s.pod.cpu.usage",
         aggregationType: MetricsAggregationType.Avg,
-        legend: "CPU Utilization",
+        legend: "CPU Cores",
       },
     }),
     createChartComponent({
@@ -1072,24 +1073,24 @@ function createKubernetesDashboardConfig(): DashboardViewConfig {
     }),
 
     /*
-     * Row 11-13: CPU gauge (auto-scaled from [0,1] to percent), and the
-     * network throughput chart. The old "Memory Utilization" gauge over
-     * raw bytes is gone — see top-of-function comment.
+     * Row 11-13: cluster CPU cores tile and the network throughput
+     * chart. This was a 0-100 CPU gauge, but the cores-valued
+     * `k8s.node.cpu.utilization` pinned it to nonsense (e.g. 711%) and
+     * the templated renderer can't divide by allocatable CPU to make a
+     * real percentage — so we show total cores in use instead. The old
+     * "Memory Utilization" gauge over raw bytes is gone — see
+     * top-of-function comment.
      */
-    createGaugeComponent({
-      title: "Cluster CPU Utilization",
+    createValueComponent({
+      title: "Cluster CPU (cores in use)",
       top: 11,
       left: 0,
       width: 4,
-      height: 3,
-      minValue: 0,
-      maxValue: 100,
-      warningThreshold: 70,
-      criticalThreshold: 90,
       metricConfig: {
-        metricName: "k8s.node.cpu.utilization",
-        aggregationType: MetricsAggregationType.Avg,
+        metricName: "k8s.node.cpu.usage",
+        aggregationType: MetricsAggregationType.Sum,
       },
+      trendDirection: DashboardValueTrendDirection.HigherIsWorse,
     }),
     createChartComponent({
       title: "Network I/O",

package/Types/Metrics/MetricQueryConfigData.ts

@@ -18,6 +18,17 @@ export default interface MetricQueryConfigData {
   getSeries?: ((data: AggregatedModel) => ChartSeries) | undefined;
   chartType?: MetricChartType | undefined;
   yAxisValueFormatter?: ((value: number) => string) | undefined;
+  /*
+   * Optional post-aggregation transform of each datapoint's plotted
+   * value. Runs before `transformAsRate`. Receives the raw aggregated
+   * value plus the full datapoint (so the transform can read grouped
+   * attributes like `resource.k8s.node.name`). Used, e.g., to turn a
+   * Kubernetes CPU *cores* value into "% of its node's allocatable CPU"
+   * by dividing each point by the node's capacity. Unset = no change.
+   */
+  transformValue?:
+    | ((value: number, dataPoint: AggregatedModel) => number)
+    | undefined;
   warningThreshold?: number | undefined;
   criticalThreshold?: number | undefined;
   /*

package/UI/Components/ModelTable/BaseModelTable.tsx

@@ -12,6 +12,7 @@ import Sort from "../../../Types/BaseDatabase/Sort";
 import Select from "../../../Types/BaseDatabase/Select";
 import { Logger } from "../../Utils/Logger";
 import Navigation from "../../Utils/Navigation";
+import TableFilterUrlState from "../../Utils/TableFilterUrlState";
 import PermissionUtil from "../../Utils/Permission";
 import ProjectUtil from "../../Utils/Project";
 import User from "../../Utils/User";
@@ -1862,6 +1863,43 @@ const BaseModelTable: <TBaseModel extends BaseModel | AnalyticsBaseModel>(
     setQuery({ ...newQuery });
   };
 
+  /*
+   * URL persistence for classic (column) filters, keyed by the table's
+   * `saveFilterProps.tableId`. Mirrors the facet persistence in
+   * `useResourceOwners` so filters survive navigating to a detail page and
+   * back, and so a filtered view is shareable. `hasRestoredUrlFilters` is
+   * state (not a ref) so the persist effect only runs after the restore has
+   * been applied — never clobbering the snapshot with the empty default.
+   */
+  const [hasRestoredUrlFilters, setHasRestoredUrlFilters] =
+    useState<boolean>(false);
+
+  useEffect(() => {
+    const restored: JSONObject | null = TableFilterUrlState.read(
+      props.saveFilterProps?.tableId,
+      "filter",
+    );
+    if (restored) {
+      /*
+       * Re-run through onFilterChanged so the derived query is rebuilt and the
+       * first fetch uses the restored filters.
+       */
+      onFilterChanged(restored as unknown as FilterData<TBaseModel>);
+    }
+    setHasRestoredUrlFilters(true);
+  }, []);
+
+  useEffect(() => {
+    if (!hasRestoredUrlFilters) {
+      return;
+    }
+    TableFilterUrlState.write(
+      props.saveFilterProps?.tableId,
+      "filter",
+      filterData as unknown as JSONObject,
+    );
+  }, [hasRestoredUrlFilters, filterData]);
+
   type GetDeleteBulkActionFunction = () => BulkActionButtonSchema<TBaseModel>;
 
   const getDeleteBulkAction: GetDeleteBulkActionFunction =

package/UI/Utils/Navigation.ts

@@ -66,6 +66,45 @@ abstract class Navigation {
     return null;
   }
 
+  /**
+   * Update (or remove) query-string params on the current URL *in place*,
+   * without pushing a new browser-history entry and without triggering a
+   * react-router navigation/re-render. Pass `null` (or "") as a value to
+   * delete that param.
+   *
+   * This is used to keep table filter/facet state in the URL so it survives
+   * navigating to a detail page and back, and so a filtered view is
+   * shareable/bookmarkable. We use `replaceState` (not push) so changing a
+   * filter doesn't flood the back-button history.
+   */
+  public static setQueryString(params: Dictionary<string | null>): void {
+    const urlSearchParams: URLSearchParams = new URLSearchParams(
+      window.location.search,
+    );
+
+    for (const paramName in params) {
+      const value: string | null =
+        params[paramName] === undefined
+          ? null
+          : (params[paramName] as string | null);
+
+      if (value === null || value === "") {
+        urlSearchParams.delete(paramName);
+      } else {
+        urlSearchParams.set(paramName, value);
+      }
+    }
+
+    const queryString: string = urlSearchParams.toString();
+
+    const newRelativeUrl: string =
+      window.location.pathname +
+      (queryString ? `?${queryString}` : "") +
+      window.location.hash;
+
+    window.history.replaceState(window.history.state, "", newRelativeUrl);
+  }
+
   public static getParamByName(
     paramName: string,
     routeTemplate: Route,

package/UI/Utils/TableFilterUrlState.ts

@@ -0,0 +1,92 @@
+import Navigation from "./Navigation";
+import { JSONObject } from "../../Types/JSON";
+import JSONFunctions from "../../Types/JSONFunctions";
+
+export type TableFilterUrlStateKind = "facets" | "filter";
+
+/**
+ * Persists a table's filter/facet selections in the URL query string so they:
+ *  - survive navigating to a detail page and clicking the browser "Back" button
+ *    (the list page remounts with the params still on the URL), and
+ *  - are shareable/bookmarkable (the URL fully describes the filtered view).
+ *
+ * The snapshot is run through {@link JSONFunctions} so OneUptime's typed query
+ * values (Search, Includes, InBetween, ...) round-trip as real class instances
+ * rather than plain objects. Params are namespaced by `tableId` so two tables on
+ * the same route don't clobber each other.
+ */
+export default class TableFilterUrlState {
+  private static getParamName(
+    tableId: string,
+    kind: TableFilterUrlStateKind,
+  ): string {
+    return `${tableId}-${kind}`;
+  }
+
+  /*
+   * Read a previously-persisted snapshot from the URL. Returns null when absent,
+   * empty, or unparseable (e.g. a hand-edited param) so callers fall back to
+   * their defaults.
+   */
+  public static read(
+    tableId: string | undefined,
+    kind: TableFilterUrlStateKind,
+  ): JSONObject | null {
+    if (!tableId) {
+      return null;
+    }
+
+    try {
+      const raw: string | null = Navigation.getQueryStringByName(
+        this.getParamName(tableId, kind),
+      );
+
+      if (!raw) {
+        return null;
+      }
+
+      const deserialized: JSONObject = JSONFunctions.deserialize(
+        JSONFunctions.parseJSONObject(raw),
+      );
+
+      if (deserialized && Object.keys(deserialized).length > 0) {
+        return deserialized;
+      }
+
+      return null;
+    } catch {
+      return null;
+    }
+  }
+
+  /*
+   * Persist a snapshot to the URL, or remove the param when the state is empty
+   * (`null`, or an object with no keys). Does not add a browser-history entry.
+   */
+  public static write(
+    tableId: string | undefined,
+    kind: TableFilterUrlStateKind,
+    state: JSONObject | null,
+  ): void {
+    if (!tableId) {
+      return;
+    }
+
+    try {
+      const hasState: boolean = Boolean(state && Object.keys(state).length > 0);
+
+      const value: string | null = hasState
+        ? JSON.stringify(JSONFunctions.serialize(state as JSONObject))
+        : null;
+
+      Navigation.setQueryString({
+        [this.getParamName(tableId, kind)]: value,
+      });
+    } catch {
+      /*
+       * Serialization failure (shouldn't happen for filter data) — skip the
+       * URL sync rather than break the table.
+       */
+    }
+  }
+}

package/build/dist/Server/Services/UserNotificationRuleService.js

@@ -1339,7 +1339,7 @@ export class Service extends DatabaseService {
             to: to,
             data: [
                 {
-                    sayMessage: "This is a call from OneUptime",
+                    sayMessage: "This is a call from One Uptime",
                 },
                 {
                     sayMessage: "A new alert has been created",
@@ -1378,7 +1378,7 @@ export class Service extends DatabaseService {
             to: to,
             data: [
                 {
-                    sayMessage: "This is a call from OneUptime",
+                    sayMessage: "This is a call from One Uptime",
                 },
                 {
                     sayMessage: "A new incident has been created",
@@ -1419,7 +1419,7 @@ export class Service extends DatabaseService {
             to: to,
             data: [
                 {
-                    sayMessage: "This is a call from OneUptime",
+                    sayMessage: "This is a call from One Uptime",
                 },
                 {
                     sayMessage: "A new alert episode has been created",