@oneuptime/common 14.0.5 → 14.0.6

package/Tests/Types/Dashboard/KubernetesDashboardTemplate.test.ts

@@ -0,0 +1,184 @@
+import AggregationType from "../../../Types/BaseDatabase/AggregationType";
+import DashboardBaseComponent from "../../../Types/Dashboard/DashboardComponents/DashboardBaseComponent";
+import DashboardComponentType from "../../../Types/Dashboard/DashboardComponentType";
+import DashboardViewConfig from "../../../Types/Dashboard/DashboardViewConfig";
+import {
+  DashboardTemplateType,
+  getTemplateConfig,
+} from "../../../Types/Dashboard/DashboardTemplates";
+import KubernetesClusterCpuTileRepair, {
+  BUSIEST_NODE_CPU_TILE_TITLE,
+  KUBERNETES_NODE_CPU_USAGE_METRIC,
+  LEGACY_CLUSTER_CPU_TILE_TITLE,
+} from "../../../Utils/Dashboard/KubernetesClusterCpuTileRepair";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * Editorial invariants for the Kubernetes template specifically. The
+ * structural rules every template must satisfy live in
+ * DashboardTemplateInvariants; this file pins the aggregation of the
+ * Kubernetes Value tiles.
+ *
+ * Every metric the Kubernetes template reads into a Value tile is a gauge
+ * the agent re-emits for every node or pod on every scrape. A Value tile
+ * reduces the whole window to one number: the server aggregates each time
+ * bucket over every series and scrape in it, and the widget then folds the
+ * buckets (ValueWidgetData.aggregateValues). With `Sum` both steps add, so
+ * the number grows with the node count, the scrape rate and the window:
+ * "Cluster CPU (cores in use)" read ~540 for three nodes on 1.5 cores each
+ * over the default hour. Avg, Max and Min have no such multiplier.
+ */
+
+function loadKubernetesTemplate(): DashboardViewConfig {
+  const config: DashboardViewConfig | null = getTemplateConfig(
+    DashboardTemplateType.Kubernetes,
+  );
+
+  if (!config) {
+    throw new Error("Expected the Kubernetes template to resolve to a config");
+  }
+
+  return config;
+}
+
+function getArguments(
+  component: DashboardBaseComponent,
+): Record<string, unknown> {
+  return (component.arguments as Record<string, unknown>) || {};
+}
+
+function getFilterData(
+  component: DashboardBaseComponent,
+): Record<string, unknown> {
+  const queryConfig: Record<string, unknown> | undefined = getArguments(
+    component,
+  )["metricQueryConfig"] as Record<string, unknown> | undefined;
+  const queryData: Record<string, unknown> | undefined = queryConfig?.[
+    "metricQueryData"
+  ] as Record<string, unknown> | undefined;
+
+  return (queryData?.["filterData"] as Record<string, unknown>) || {};
+}
+
+function getValueTiles(
+  config: DashboardViewConfig,
+): Array<DashboardBaseComponent> {
+  return config.components.filter(
+    (component: DashboardBaseComponent): boolean => {
+      return component.componentType === DashboardComponentType.Value;
+    },
+  );
+}
+
+function describeTile(component: DashboardBaseComponent): string {
+  const filterData: Record<string, unknown> = getFilterData(component);
+
+  return `"${String(getArguments(component)["title"])}" ${String(
+    filterData["metricName"],
+  )}/${String(filterData["aggegationType"])}`;
+}
+
+describe("Kubernetes dashboard template", () => {
+  describe("busiest node CPU tile", () => {
+    function findNodeCpuTiles(): Array<DashboardBaseComponent> {
+      return getValueTiles(loadKubernetesTemplate()).filter(
+        (component: DashboardBaseComponent): boolean => {
+          return (
+            getFilterData(component)["metricName"] ===
+            KUBERNETES_NODE_CPU_USAGE_METRIC
+          );
+        },
+      );
+    }
+
+    test("reads k8s.node.cpu.usage with Max, never Sum", (): void => {
+      const busiestNodeTile: DashboardBaseComponent | undefined =
+        findNodeCpuTiles().find((component: DashboardBaseComponent) => {
+          return (
+            getArguments(component)["title"] === BUSIEST_NODE_CPU_TILE_TITLE
+          );
+        });
+
+      expect(busiestNodeTile).toBeDefined();
+      expect(getFilterData(busiestNodeTile!)["aggegationType"]).toBe(
+        AggregationType.Max,
+      );
+    });
+
+    test("no longer ships the summed cluster CPU tile under any title", (): void => {
+      const nodeCpuTiles: Array<DashboardBaseComponent> = findNodeCpuTiles();
+
+      expect(nodeCpuTiles.length).toBeGreaterThan(0);
+
+      for (const component of nodeCpuTiles) {
+        expect(describeTile(component)).not.toContain(
+          `/${AggregationType.Sum}`,
+        );
+        expect(getArguments(component)["title"]).not.toBe(
+          LEGACY_CLUSTER_CPU_TILE_TITLE,
+        );
+      }
+    });
+
+    /*
+     * The migration writes BUSIEST_NODE_CPU_TILE_TITLE and Max onto
+     * existing dashboards. If the template and the repair drift apart, a
+     * repaired dashboard and a freshly created one show different tiles.
+     */
+    test("is exactly what the repair writes onto existing dashboards", (): void => {
+      const busiestNodeTile: DashboardBaseComponent | undefined =
+        findNodeCpuTiles().find((component: DashboardBaseComponent) => {
+          return (
+            getArguments(component)["title"] === BUSIEST_NODE_CPU_TILE_TITLE
+          );
+        });
+
+      expect(busiestNodeTile).toBeDefined();
+
+      const legacyTile: DashboardBaseComponent = JSON.parse(
+        JSON.stringify(busiestNodeTile),
+      );
+      (legacyTile.arguments as Record<string, unknown>)["title"] =
+        LEGACY_CLUSTER_CPU_TILE_TITLE;
+      getFilterData(legacyTile)["aggegationType"] = AggregationType.Sum;
+
+      const repaired: ReturnType<typeof KubernetesClusterCpuTileRepair.repair> =
+        KubernetesClusterCpuTileRepair.repair({ components: [legacyTile] });
+
+      expect(repaired).not.toBeNull();
+      expect(
+        (repaired!.config["components"] as Array<unknown>)[0],
+      ).toStrictEqual(JSON.parse(JSON.stringify(busiestNodeTile)));
+    });
+
+    test("is not matched by the repair, so a new dashboard is never rewritten", (): void => {
+      expect(
+        KubernetesClusterCpuTileRepair.repair(
+          JSON.parse(JSON.stringify(loadKubernetesTemplate())),
+        )?.repairedTileCount ?? 0,
+      ).toBe(0);
+    });
+  });
+
+  test("no Value tile sums a per-resource gauge across the window", (): void => {
+    const valueTiles: Array<DashboardBaseComponent> = getValueTiles(
+      loadKubernetesTemplate(),
+    );
+
+    expect(valueTiles.length).toBeGreaterThan(0);
+
+    for (const component of valueTiles) {
+      const aggregation: unknown = getFilterData(component)["aggegationType"];
+
+      expect(describeTile(component)).toBe(
+        `"${String(getArguments(component)["title"])}" ${String(
+          getFilterData(component)["metricName"],
+        )}/${
+          aggregation === AggregationType.Sum
+            ? "<not Sum>"
+            : String(aggregation)
+        }`,
+      );
+    }
+  });
+});

package/Tests/Types/Dashboard/KubernetesDashboardTemplates.test.ts

@@ -0,0 +1,107 @@
+import DashboardViewConfig from "../../../Types/Dashboard/DashboardViewConfig";
+import {
+  DashboardTemplateType,
+  getTemplateConfig,
+} from "../../../Types/Dashboard/DashboardTemplates";
+import { AGENT_EMITTED_METRIC_NAMES } from "../Monitor/Utils/KubernetesAgentEmittedMetrics";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The Kubernetes dashboard templates chart what the kubernetes-agent chart
+ * sends, and nothing else feeds them. A widget naming a metric the agent
+ * never sends does not error — its query returns zero rows and the widget
+ * renders empty on every dashboard created from the template.
+ *
+ * That shipped: the Kubernetes template's four CPU widgets read
+ * `k8s.pod.cpu.usage` and `k8s.node.cpu.usage`, which kubeletstats at the
+ * pinned collector leaves off by default, before the chart enabled them.
+ * Nothing checked the dashboards against AGENT_EMITTED_METRIC_NAMES, so
+ * this holds every widget of both templates to it.
+ */
+const KUBERNETES_TEMPLATE_TYPES: Array<DashboardTemplateType> = [
+  DashboardTemplateType.Kubernetes,
+  DashboardTemplateType.KubernetesCost,
+];
+
+interface MetricQuery {
+  widget: string;
+  metricName: string;
+}
+
+function getConfig(type: DashboardTemplateType): DashboardViewConfig {
+  const config: DashboardViewConfig | null = getTemplateConfig(type);
+
+  if (!config) {
+    throw new Error(`Expected ${type} to resolve to a config`);
+  }
+
+  return config;
+}
+
+/*
+ * Every `filterData.metricName` anywhere in a widget's arguments, so a
+ * widget that carries several queries cannot hide one from the check.
+ */
+function collectMetricNames(value: unknown, into: Array<string>): void {
+  if (!value || typeof value !== "object") {
+    return;
+  }
+
+  const record: Record<string, unknown> = value as Record<string, unknown>;
+  const filterData: Record<string, unknown> | undefined = record[
+    "filterData"
+  ] as Record<string, unknown> | undefined;
+
+  if (filterData && typeof filterData["metricName"] === "string") {
+    into.push(filterData["metricName"]);
+  }
+
+  for (const child of Object.values(record)) {
+    collectMetricNames(child, into);
+  }
+}
+
+function getMetricQueries(type: DashboardTemplateType): Array<MetricQuery> {
+  const queries: Array<MetricQuery> = [];
+
+  for (const component of getConfig(type).components) {
+    const args: Record<string, unknown> =
+      (component.arguments as Record<string, unknown>) || {};
+    const label: unknown =
+      args["title"] ??
+      args["chartTitle"] ??
+      args["gaugeTitle"] ??
+      args["tableTitle"];
+    const metricNames: Array<string> = [];
+
+    collectMetricNames(args, metricNames);
+
+    for (const metricName of metricNames) {
+      queries.push({
+        widget: `${component.componentType} "${String(label ?? "<untitled>")}"`,
+        metricName: metricName,
+      });
+    }
+  }
+
+  return queries;
+}
+
+describe("Kubernetes dashboard templates", () => {
+  describe.each(KUBERNETES_TEMPLATE_TYPES)(
+    "%s",
+    (type: DashboardTemplateType) => {
+      test("queries at least one metric (guards the guard)", () => {
+        expect(getMetricQueries(type).length).toBeGreaterThan(0);
+      });
+
+      test("every widget queries a metric the agent emits", () => {
+        for (const query of getMetricQueries(type)) {
+          expect(
+            `${query.widget} → ${query.metricName} emitted: ${AGENT_EMITTED_METRIC_NAMES.has(query.metricName)}`,
+          ).toBe(`${query.widget} → ${query.metricName} emitted: true`);
+        }
+      });
+    },
+  );
+});

package/Tests/Types/Monitor/KubernetesAlertTemplates.test.ts

@@ -1161,25 +1161,19 @@ describe("KubernetesAlertTemplates - deployment replica mismatch", () => {
   });
 
   /*
-   * The same bug, generalised: any template reading a k8s_cluster or
-   * kubeletstats series must read one the agent actually sends. That
-   * covers node, pod and container metrics too, including the kubeletstats
-   * ones that are off upstream and on only because the chart enables them
-   * (see the high node CPU block below). Undotted names come from the
-   * chart's Prometheus scrapes (control plane, cAdvisor, kube-state-metrics),
-   * which this list does not cover.
+   * The same bug, generalised: every query of every template must read a
+   * series the agent actually sends, whichever receiver or scrape it comes
+   * from. That covers node, pod and container metrics, including the
+   * kubeletstats ones that are off upstream and on only because the chart
+   * enables them (see the high node CPU block below), and the undotted
+   * names from the chart's Prometheus scrapes — control plane, cAdvisor,
+   * kube-state-metrics, cost engine.
    */
-  test("no template queries a k8s_cluster or kubeletstats metric the agent does not emit", () => {
-    const receiverMetric: RegExp = /^(k8s|container)\./;
-
+  test("no template queries a metric the agent does not emit", () => {
     for (const template of getAllKubernetesAlertTemplates()) {
       for (const query of getQueryConfigs(template.id)) {
         const metricName: string = query.metricQueryData.filterData.metricName;
 
-        if (!receiverMetric.test(metricName)) {
-          continue;
-        }
-
         expect(`${template.id}: ${metricName}`).toBe(
           AGENT_EMITTED_METRIC_NAMES.has(metricName)
             ? `${template.id}: ${metricName}`

package/Tests/Types/Monitor/KubernetesMetricCatalog.test.ts

@@ -526,9 +526,10 @@ describe("KubernetesMetricCatalog", () => {
   describe("every entry names a metric the shipped agent emits", () => {
     test("the agent chart still pins the collector these names were read from", () => {
       /*
-       * AGENT_EMITTED_METRIC_NAMES is the receivers' metadata.yaml at this
-       * collector version. Bumping the image fails here until that list is
-       * re-read — receivers rename metrics between versions.
+       * The receiver half of AGENT_EMITTED_METRIC_NAMES is the receivers'
+       * metadata.yaml at this collector version. Bumping the image fails
+       * here until that list is re-read — receivers rename metrics between
+       * versions.
        */
       const values: Record<string, any> = readAgentChartValues();
 

package/Tests/Types/Monitor/Utils/KubernetesAgentEmittedMetrics.ts

@@ -161,12 +161,6 @@ export const CONTROL_PLANE_SCRAPE_METRICS: ReadonlyArray<string> = [
   "scheduler_pending_pods",
 ];
 
-export const AGENT_EMITTED_METRIC_NAMES: ReadonlySet<string> = new Set<string>([
-  ...K8S_CLUSTER_RECEIVER_METRICS,
-  ...KUBELETSTATS_RECEIVER_METRICS,
-  ...CONTROL_PLANE_SCRAPE_METRICS,
-]);
-
 const AGENT_CHART_VALUES_PATH: string = path.resolve(
   __dirname,
   "../../../../../../HelmChart/Public/kubernetes-agent/values.yaml",
@@ -179,3 +173,30 @@ export function readAgentChartValues(): Record<string, any> {
     any
   >;
 }
+
+/*
+ * The chart's Prometheus scrapes that carry an allowlist — cAdvisor on the
+ * DaemonSet (on by default), kube-state-metrics and the cost engine on the
+ * Deployment (opt-in). Each job's `metric_relabel_configs` keeps exactly
+ * `^(<allowlist joined by |>)$`, and the prometheus receiver trims `_total`
+ * and unit suffixes only under `trim_metric_suffixes`, which is off by
+ * default and which the chart never sets. So the names that arrive are the
+ * allowlist entries verbatim — read from values.yaml rather than copied,
+ * so the two cannot drift.
+ */
+const agentChartValues: Record<string, any> = readAgentChartValues();
+
+export const ALLOWLISTED_SCRAPE_METRICS: ReadonlyArray<string> = [
+  ...(agentChartValues["cadvisor"]["metricsAllowlist"] as Array<string>),
+  ...(agentChartValues["kubeStateMetrics"][
+    "metricsAllowlist"
+  ] as Array<string>),
+  ...(agentChartValues["cost"]["metrics"]["metricsAllowlist"] as Array<string>),
+];
+
+export const AGENT_EMITTED_METRIC_NAMES: ReadonlySet<string> = new Set<string>([
+  ...K8S_CLUSTER_RECEIVER_METRICS,
+  ...KUBELETSTATS_RECEIVER_METRICS,
+  ...CONTROL_PLANE_SCRAPE_METRICS,
+  ...ALLOWLISTED_SCRAPE_METRICS,
+]);

package/Tests/UI/Rum/ChunkLoader.test.ts

@@ -1845,6 +1845,82 @@ describe("ChunkLoader signal extraction", () => {
     expect(longTask?.offsetMs).toBe(9000);
   });
 
+  /*
+   * Issue #3975: an INP is now reported per single-page-app view, with
+   * the view's url and the slow interaction's attribution. Each field is
+   * read on its own, so one a newer or buggier recorder got wrong costs
+   * only that field.
+   */
+  it("carries an INP's view and attribution, dropping only the fields that are malformed", () => {
+    const rows: Array<ReplayTimelineEvent> = ChunkLoader.extractTimelineEvents(
+      makeEntry(0),
+      [
+        { type: 2, timestamp: CUSTOM_BASE_TS, data: {} },
+        custom(
+          "oneuptime.performance",
+          {
+            kind: "web-vital",
+            metric: "INP",
+            value: 480,
+            rating: "needs-improvement",
+            url: "https://shop.example.com/products",
+            navigationType: "soft",
+            interactionType: "pointer",
+            interactionTarget: "nav > a.product-link",
+            inputDelayMs: 5,
+            processingDurationMs: 305,
+            presentationDelayMs: 170,
+          },
+          CUSTOM_BASE_TS + 100,
+        ),
+        custom(
+          "oneuptime.performance",
+          {
+            kind: "web-vital",
+            metric: "INP",
+            value: 90,
+            rating: "good",
+            navigationType: "sideways",
+            interactionType: 7,
+            interactionTarget: "",
+            inputDelayMs: -3,
+            processingDurationMs: "12",
+            presentationDelayMs: 40,
+          },
+          CUSTOM_BASE_TS + 200,
+        ),
+      ],
+    );
+
+    const [attributed, malformed] = rows.filter(
+      (row: ReplayTimelineEvent): boolean => {
+        return row.metric === "INP";
+      },
+    );
+
+    expect(attributed).toEqual(
+      expect.objectContaining({
+        value: 480,
+        url: "https://shop.example.com/products",
+        navigationType: "soft",
+        interactionType: "pointer",
+        interactionTarget: "nav > a.product-link",
+        inputDelayMs: 5,
+        processingDurationMs: 305,
+        presentationDelayMs: 170,
+      }),
+    );
+
+    /* The row itself survives; only the bad fields are gone. */
+    expect(malformed?.value).toBe(90);
+    expect(malformed?.presentationDelayMs).toBe(40);
+    expect(malformed?.navigationType).toBeUndefined();
+    expect(malformed?.interactionType).toBeUndefined();
+    expect(malformed?.interactionTarget).toBeUndefined();
+    expect(malformed?.inputDelayMs).toBeUndefined();
+    expect(malformed?.processingDurationMs).toBeUndefined();
+  });
+
   it("turns rrweb Meta events into navigation rows carrying the viewport", () => {
     const rows: Array<ReplayTimelineEvent> = ChunkLoader.extractTimelineEvents(
       makeEntry(0),

package/Tests/UI/Rum/ReplayRailDetail.test.tsx

@@ -983,4 +983,57 @@ describe("ReplayRailDetail performance wording", () => {
     expect(screen.getByText("Long task")).toBeInTheDocument();
     expect(screen.queryByText("long-task")).toBeNull();
   });
+
+  /* Issue #3975: which view, which element, and where the time went. */
+  it("explains a slow INP: the view, the input, the element and the phase split", () => {
+    renderDetail(
+      performanceSignal({
+        kind: "web-vital",
+        durationMs: null,
+        budgetMs: null,
+        isOverBudget: true,
+        metric: "INP",
+        value: 480,
+        rating: "needs-improvement",
+        url: "https://shop.example.com/products",
+        atUnixMs: null,
+        navigationType: "soft",
+        interactionType: "pointer",
+        interactionTarget: "nav > a.product-link",
+        inputDelayMs: 5,
+        processingDurationMs: 305,
+        presentationDelayMs: 170,
+      }),
+    );
+
+    expect(
+      screen.getByText("Route change (single-page app)"),
+    ).toBeInTheDocument();
+    expect(screen.getByText("Pointer")).toBeInTheDocument();
+    expect(screen.getByText("nav > a.product-link")).toBeInTheDocument();
+    expect(screen.getByText("Input delay")).toBeInTheDocument();
+    expect(screen.getByText("Processing")).toBeInTheDocument();
+    expect(screen.getByText("Presentation")).toBeInTheDocument();
+    expect(screen.getByText("305ms")).toBeInTheDocument();
+  });
+
+  it("shows none of the INP rows for a recording that predates them", () => {
+    renderDetail(
+      performanceSignal({
+        kind: "web-vital",
+        durationMs: null,
+        budgetMs: null,
+        isOverBudget: false,
+        metric: "INP",
+        value: 120,
+        rating: "good",
+        url: null,
+        atUnixMs: null,
+      }),
+    );
+
+    expect(screen.queryByText("View")).toBeNull();
+    expect(screen.queryByText("Element")).toBeNull();
+    expect(screen.queryByText("Input delay")).toBeNull();
+  });
 });

package/Tests/UI/Rum/ReplaySignals.test.ts

@@ -646,6 +646,60 @@ describe("performance rows", () => {
     expect(signal.severity).toBe("info");
     expect(signal.title).not.toContain("0ms");
   });
+
+  /* Issue #3975: an INP per view, labelled with the route it measured. */
+  it("carries an INP's view and attribution into the detail, and the route into the subtitle", () => {
+    const signal: ReplaySignal = fromTimelineEvent(
+      makeEvent("performance", {
+        performanceKind: "web-vital",
+        metric: "INP",
+        value: 480,
+        rating: "needs-improvement",
+        url: "https://shop.example.com/products",
+        navigationType: "soft",
+        interactionType: "keyboard",
+        interactionTarget: "input#search",
+        inputDelayMs: 12,
+        processingDurationMs: 400,
+        presentationDelayMs: 68,
+      }),
+      { startTimeUnixMs: null },
+    );
+    const detail: ReplayPerformanceSignalDetail =
+      signal.detail as ReplayPerformanceSignalDetail;
+
+    expect(signal.title).toBe("INP 480ms needs improvement");
+    expect(signal.subtitle).toBe("/products");
+    expect(detail).toEqual(
+      expect.objectContaining({
+        navigationType: "soft",
+        interactionType: "keyboard",
+        interactionTarget: "input#search",
+        inputDelayMs: 12,
+        processingDurationMs: 400,
+        presentationDelayMs: 68,
+      }),
+    );
+  });
+
+  it("leaves the attribution empty for a recording that predates it", () => {
+    const detail: ReplayPerformanceSignalDetail = fromTimelineEvent(
+      makeEvent("performance", {
+        performanceKind: "web-vital",
+        metric: "INP",
+        value: 320,
+        rating: "poor",
+      }),
+      { startTimeUnixMs: null },
+    ).detail as ReplayPerformanceSignalDetail;
+
+    expect(detail.navigationType).toBeNull();
+    expect(detail.interactionType).toBeNull();
+    expect(detail.interactionTarget).toBeNull();
+    expect(detail.inputDelayMs).toBeNull();
+    expect(detail.processingDurationMs).toBeNull();
+    expect(detail.presentationDelayMs).toBeNull();
+  });
 });
 
 describe("custom and marker rows", () => {