@oneuptime/common 14.0.5 → 14.0.7

package/Tests/Types/BaseDatabase/AggregationType.test.ts

@@ -9,14 +9,16 @@ describe("AggregationType", () => {
   describe("PercentileAggregationLevels", () => {
     test("maps each percentile enum to its quantile fraction", () => {
       expect(PercentileAggregationLevels[AggregationType.P50]).toBe(0.5);
+      expect(PercentileAggregationLevels[AggregationType.P75]).toBe(0.75);
       expect(PercentileAggregationLevels[AggregationType.P90]).toBe(0.9);
       expect(PercentileAggregationLevels[AggregationType.P95]).toBe(0.95);
       expect(PercentileAggregationLevels[AggregationType.P99]).toBe(0.99);
     });
 
-    test("contains exactly the four percentile aggregations", () => {
+    test("contains exactly the five percentile aggregations", () => {
       expect(Object.keys(PercentileAggregationLevels).sort()).toEqual([
         "P50",
+        "P75",
         "P90",
         "P95",
         "P99",
@@ -27,6 +29,7 @@ describe("AggregationType", () => {
   describe("isPercentileAggregation", () => {
     test("returns true for every percentile aggregation", () => {
       expect(isPercentileAggregation(AggregationType.P50)).toBe(true);
+      expect(isPercentileAggregation(AggregationType.P75)).toBe(true);
       expect(isPercentileAggregation(AggregationType.P90)).toBe(true);
       expect(isPercentileAggregation(AggregationType.P95)).toBe(true);
       expect(isPercentileAggregation(AggregationType.P99)).toBe(true);
@@ -44,6 +47,7 @@ describe("AggregationType", () => {
   describe("getPercentileLevel", () => {
     test("returns the quantile fraction for percentile aggregations", () => {
       expect(getPercentileLevel(AggregationType.P50)).toBe(0.5);
+      expect(getPercentileLevel(AggregationType.P75)).toBe(0.75);
       expect(getPercentileLevel(AggregationType.P99)).toBe(0.99);
     });
 

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/Types/Topology/TopologyTypeRules.test.ts

@@ -0,0 +1,176 @@
+import { describe, expect, test } from "@jest/globals";
+import { compareCodePoints } from "../../../Types/Topology/TopologyTypeRules";
+
+/*
+ * compareCodePoints is how the Dashboard breaks the ties the server breaks
+ * with COLLATE "C" (code-point order on a UTF-8 database). It must equal
+ * JavaScript's `<` for every string made of characters up to U+FFFF, and
+ * order characters beyond U+FFFF (surrogate pairs) after U+E000-U+FFFF,
+ * which `<` does not.
+ */
+
+function sign(value: number): number {
+  return value < 0 ? -1 : value > 0 ? 1 : 0;
+}
+
+/* An independent reference: compare the strings' code points one by one. */
+function referenceCompare(a: string, b: string): number {
+  const left: Array<number> = Array.from(a).map((char: string): number => {
+    return char.codePointAt(0)!;
+  });
+  const right: Array<number> = Array.from(b).map((char: string): number => {
+    return char.codePointAt(0)!;
+  });
+  const length: number = Math.min(left.length, right.length);
+  for (let index: number = 0; index < length; index++) {
+    if (left[index] !== right[index]) {
+      return left[index]! < right[index]! ? -1 : 1;
+    }
+  }
+  return sign(left.length - right.length);
+}
+
+function codeUnitCompare(a: string, b: string): number {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+/* A small deterministic generator, so a failure names its inputs. */
+function makeRandom(seed: number): () => number {
+  let state: number = seed >>> 0;
+  return (): number => {
+    state = (state * 1664525 + 1013904223) >>> 0;
+    return state / 4294967296;
+  };
+}
+
+/* Characters from the ranges where the two orders meet or part ways. */
+const ALPHABET: Array<string> = [
+  "a",
+  "b",
+  "z",
+  "0",
+  "-",
+  "é",
+  "中",
+  "퟿",
+  "",
+  "",
+  "fi",
+  "�",
+  "￿",
+  "\u{10000}",
+  "\u{1F600}",
+  "\u{1F601}",
+  "\u{10FFFF}",
+];
+
+function randomString(random: () => number, alphabet: Array<string>): string {
+  const length: number = Math.floor(random() * 5);
+  let out: string = "";
+  for (let index: number = 0; index < length; index++) {
+    out += alphabet[Math.floor(random() * alphabet.length)]!;
+  }
+  return out;
+}
+
+describe("compareCodePoints", () => {
+  test("equal strings compare equal", () => {
+    expect(compareCodePoints("", "")).toBe(0);
+    expect(compareCodePoints("node-a", "node-a")).toBe(0);
+    expect(compareCodePoints("\u{1F600}", "\u{1F600}")).toBe(0);
+  });
+
+  test("inside the Basic Multilingual Plane it orders exactly like `<`", () => {
+    const pairs: Array<[string, string]> = [
+      ["a", "b"],
+      ["node-a", "node-b"],
+      ["node", "node-a"],
+      ["", "a"],
+      ["Z", "a"],
+      ["a", "é"],
+      ["퟿", ""],
+      ["", "�"],
+      ["�", "￿"],
+      ["0123456789abcdef", "0123456789abcdf0"],
+    ];
+    for (const [a, b] of pairs) {
+      expect(compareCodePoints(a, b)).toBe(-1);
+      expect(compareCodePoints(b, a)).toBe(1);
+      expect(sign(compareCodePoints(a, b))).toBe(codeUnitCompare(a, b));
+    }
+  });
+
+  test("a character beyond U+FFFF sorts after U+E000..U+FFFF, where `<` puts it before", () => {
+    for (const high of ["", "", "�", "￿"]) {
+      for (const astral of ["\u{10000}", "\u{1F600}", "\u{10FFFF}"]) {
+        expect(compareCodePoints(high, astral)).toBe(-1);
+        expect(compareCodePoints(astral, high)).toBe(1);
+        expect(compareCodePoints(`node-${high}`, `node-${astral}`)).toBe(-1);
+        expect(compareCodePoints(`node-${astral}x`, `node-${high}`)).toBe(1);
+        /* The order `<` gives, which is what this exists to correct. */
+        expect(codeUnitCompare(high, astral)).toBe(1);
+      }
+    }
+  });
+
+  test("a character beyond U+FFFF still sorts after everything below U+D800", () => {
+    expect(compareCodePoints("퟿", "\u{10000}")).toBe(-1);
+    expect(compareCodePoints("z", "\u{1F600}")).toBe(-1);
+    expect(compareCodePoints("\u{1F600}", "z")).toBe(1);
+  });
+
+  test("two characters beyond U+FFFF compare by code point, high or low half", () => {
+    /* Different high surrogates (U+10000 is D800 DC00, U+1F600 is D83D DE00). */
+    expect(compareCodePoints("\u{10000}", "\u{1F600}")).toBe(-1);
+    /* Same high surrogate, different low surrogates. */
+    expect(compareCodePoints("\u{1F600}", "\u{1F601}")).toBe(-1);
+    expect(compareCodePoints("x\u{1F601}", "x\u{1F600}")).toBe(1);
+  });
+
+  test("a prefix sorts first", () => {
+    expect(compareCodePoints("node", "node-\u{1F600}")).toBe(-1);
+    expect(compareCodePoints("node-\u{1F600}", "node")).toBe(1);
+    expect(compareCodePoints("\u{1F600}", "\u{1F600}")).toBe(-1);
+  });
+
+  test("agrees with a code-point reference on thousands of mixed strings", () => {
+    const random: () => number = makeRandom(3973);
+    let disagreementsWithCodeUnits: number = 0;
+    for (let round: number = 0; round < 20000; round++) {
+      const a: string = randomString(random, ALPHABET);
+      const b: string = randomString(random, ALPHABET);
+      const expected: number = referenceCompare(a, b);
+      if (sign(compareCodePoints(a, b)) !== expected) {
+        throw new Error(
+          `compareCodePoints(${JSON.stringify(a)}, ${JSON.stringify(b)}) should be ${expected}`,
+        );
+      }
+      if (codeUnitCompare(a, b) !== expected) {
+        disagreementsWithCodeUnits++;
+      }
+    }
+    /* The inputs really did reach the cases where `<` is wrong. */
+    expect(disagreementsWithCodeUnits).toBeGreaterThan(100);
+  });
+
+  test('sorts a list the way COLLATE "C" would', () => {
+    const keys: Array<string> = [
+      "node-\u{1F600}",
+      "node-�",
+      "node-b",
+      "node-",
+      "node-a",
+      "node-\u{10000}",
+      "node",
+    ];
+    expect([...keys].sort(compareCodePoints)).toEqual([
+      "node",
+      "node-a",
+      "node-b",
+      "node-",
+      "node-�",
+      "node-\u{10000}",
+      "node-\u{1F600}",
+    ]);
+  });
+});

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),