@oneuptime/common 14.0.5 → 14.0.6

package/Tests/Utils/Dashboard/KubernetesClusterCpuTileRepair.test.ts

@@ -0,0 +1,370 @@
+import AggregationType from "../../../Types/BaseDatabase/AggregationType";
+import { JSONObject } from "../../../Types/JSON";
+import KubernetesClusterCpuTileRepair, {
+  BUSIEST_NODE_CPU_TILE_TITLE,
+  KUBERNETES_NODE_CPU_USAGE_METRIC,
+  KubernetesClusterCpuTileRepairResult,
+  LEGACY_CLUSTER_CPU_TILE_TITLE,
+} from "../../../Utils/Dashboard/KubernetesClusterCpuTileRepair";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The repair behind the RepairKubernetesDashboardClusterCpuTile migration.
+ * Existing Kubernetes dashboards hold a COPY of the template, so their
+ * "Cluster CPU (cores in use)" tile still sums k8s.node.cpu.usage over every
+ * node, scrape and bucket. What is pinned here: exactly which tiles are
+ * rewritten, to what, that nothing else on the dashboard moves, and that
+ * the Postgres filter the migration selects rows with agrees with the
+ * in-memory matcher.
+ *
+ * Fixtures are shaped like a stored dashboardViewConfig: plain jsonb, with
+ * componentId serialised as { _type: "ObjectID", value } and the
+ * misspelled `aggegationType` the fetch layer reads.
+ */
+
+function makeValueTile(data: {
+  componentId?: string;
+  title?: string;
+  metricName?: string;
+  aggregation?: string;
+  extraArguments?: JSONObject;
+  extraFilterData?: JSONObject;
+}): JSONObject {
+  return {
+    _type: "DashboardComponent",
+    componentType: "Value",
+    componentId: {
+      _type: "ObjectID",
+      value: data.componentId || "0b6a2c3e-0000-4000-8000-000000000001",
+    },
+    topInDashboardUnits: 11,
+    leftInDashboardUnits: 0,
+    widthInDashboardUnits: 4,
+    heightInDashboardUnits: 1,
+    minHeightInDashboardUnits: 1,
+    minWidthInDashboardUnits: 1,
+    arguments: {
+      title: data.title ?? LEGACY_CLUSTER_CPU_TILE_TITLE,
+      metricQueryConfig: {
+        metricQueryData: {
+          filterData: {
+            metricName: data.metricName ?? KUBERNETES_NODE_CPU_USAGE_METRIC,
+            aggegationType: data.aggregation ?? AggregationType.Sum,
+            ...(data.extraFilterData || {}),
+          },
+        },
+      },
+      trendDirection: "HigherIsWorse",
+      ...(data.extraArguments || {}),
+    },
+  };
+}
+
+function makeConfig(components: Array<unknown>): JSONObject {
+  return {
+    _type: "DashboardViewConfig",
+    heightInDashboardUnits: 21,
+    variables: [
+      {
+        id: "cluster",
+        name: "Cluster",
+        type: "Telemetry Attribute",
+        attributeKey: "resource.k8s.cluster.name",
+      },
+    ],
+    components: components as Array<JSONObject>,
+  };
+}
+
+function componentsOf(config: JSONObject): Array<JSONObject> {
+  return config["components"] as Array<JSONObject>;
+}
+
+function filterDataOf(component: JSONObject): JSONObject {
+  const args: JSONObject = component["arguments"] as JSONObject;
+  const metricQueryConfig: JSONObject = args["metricQueryConfig"] as JSONObject;
+  const metricQueryData: JSONObject = metricQueryConfig[
+    "metricQueryData"
+  ] as JSONObject;
+
+  return metricQueryData["filterData"] as JSONObject;
+}
+
+/*
+ * Postgres `@>` for jsonb, as documented (8.14.3): an object contains
+ * another when every key of the right side is present and contains its
+ * value; an array contains another when every element of the right side is
+ * contained by SOME element of the left; scalars must be equal. Used only to
+ * show that the migration's SQL filter and isLegacyTile pick the same rows.
+ */
+function jsonbContains(left: unknown, right: unknown): boolean {
+  if (Array.isArray(right)) {
+    return (
+      Array.isArray(left) &&
+      right.every((rightItem: unknown) => {
+        return left.some((leftItem: unknown) => {
+          return jsonbContains(leftItem, rightItem);
+        });
+      })
+    );
+  }
+
+  if (right && typeof right === "object") {
+    if (!left || typeof left !== "object" || Array.isArray(left)) {
+      return false;
+    }
+
+    return Object.entries(right as JSONObject).every(
+      ([key, value]: [string, unknown]) => {
+        return (
+          Object.prototype.hasOwnProperty.call(left, key) &&
+          jsonbContains((left as JSONObject)[key], value)
+        );
+      },
+    );
+  }
+
+  return left === right;
+}
+
+const TEXT_HEADER: JSONObject = {
+  _type: "DashboardComponent",
+  componentType: "Text",
+  componentId: { _type: "ObjectID", value: "text-header" },
+  arguments: { text: "Resource Health", isBold: true },
+};
+
+const NETWORK_CHART: JSONObject = {
+  _type: "DashboardComponent",
+  componentType: "Chart",
+  componentId: { _type: "ObjectID", value: "network-chart" },
+  arguments: {
+    chartTitle: "Network I/O",
+    metricQueryConfig: {
+      metricQueryData: {
+        filterData: {
+          metricName: "k8s.pod.network.io",
+          aggegationType: AggregationType.Sum,
+        },
+      },
+    },
+  },
+};
+
+describe("KubernetesClusterCpuTileRepair", () => {
+  describe("repair", () => {
+    test("rewrites the legacy tile to the busiest node's peak CPU", () => {
+      const result: KubernetesClusterCpuTileRepairResult | null =
+        KubernetesClusterCpuTileRepair.repair(
+          makeConfig([TEXT_HEADER, makeValueTile({}), NETWORK_CHART]),
+        );
+
+      expect(result).not.toBeNull();
+      expect(result!.repairedTileCount).toBe(1);
+
+      const tile: JSONObject = componentsOf(result!.config)[1]!;
+      expect((tile["arguments"] as JSONObject)["title"]).toBe(
+        BUSIEST_NODE_CPU_TILE_TITLE,
+      );
+      expect(filterDataOf(tile)["aggegationType"]).toBe(AggregationType.Max);
+      expect(filterDataOf(tile)["metricName"]).toBe(
+        KUBERNETES_NODE_CPU_USAGE_METRIC,
+      );
+    });
+
+    test("changes only the title and the aggregation", () => {
+      const original: JSONObject = makeConfig([
+        TEXT_HEADER,
+        makeValueTile({
+          extraArguments: { warningThreshold: 3, criticalThreshold: 6 },
+          extraFilterData: { attributes: { "resource.k8s.node.name": "a" } },
+        }),
+        NETWORK_CHART,
+      ]);
+
+      const expected: JSONObject = JSON.parse(JSON.stringify(original));
+      const expectedTile: JSONObject = componentsOf(expected)[1]!;
+      (expectedTile["arguments"] as JSONObject)["title"] =
+        BUSIEST_NODE_CPU_TILE_TITLE;
+      filterDataOf(expectedTile)["aggegationType"] = AggregationType.Max;
+
+      expect(KubernetesClusterCpuTileRepair.repair(original)!.config).toEqual(
+        expected,
+      );
+    });
+
+    test("never mutates the config it was given", () => {
+      const original: JSONObject = makeConfig([makeValueTile({})]);
+      const snapshot: string = JSON.stringify(original);
+
+      KubernetesClusterCpuTileRepair.repair(original);
+
+      expect(JSON.stringify(original)).toBe(snapshot);
+    });
+
+    test("repairs every copy of the tile on one dashboard", () => {
+      const result: KubernetesClusterCpuTileRepairResult | null =
+        KubernetesClusterCpuTileRepair.repair(
+          makeConfig([
+            makeValueTile({ componentId: "first" }),
+            makeValueTile({ componentId: "second" }),
+          ]),
+        );
+
+      expect(result!.repairedTileCount).toBe(2);
+      for (const tile of componentsOf(result!.config)) {
+        expect(filterDataOf(tile)["aggegationType"]).toBe(AggregationType.Max);
+      }
+    });
+
+    test("is a no-op on its own output, so a second run writes nothing", () => {
+      const once: KubernetesClusterCpuTileRepairResult | null =
+        KubernetesClusterCpuTileRepair.repair(makeConfig([makeValueTile({})]));
+
+      expect(once).not.toBeNull();
+      expect(KubernetesClusterCpuTileRepair.repair(once!.config)).toBeNull();
+    });
+
+    /*
+     * The migration only corrects what the template put there. A user who
+     * renamed the tile, re-aggregated it, pointed it at another metric or
+     * drew the same query as a chart made that choice themselves.
+     */
+    test.each([
+      ["a renamed tile", makeValueTile({ title: "All Nodes CPU" })],
+      [
+        "a title that differs only in whitespace",
+        makeValueTile({ title: ` ${LEGACY_CLUSTER_CPU_TILE_TITLE}` }),
+      ],
+      [
+        "a tile already re-aggregated to Avg",
+        makeValueTile({ aggregation: AggregationType.Avg }),
+      ],
+      [
+        "a tile already re-aggregated to Max",
+        makeValueTile({ aggregation: AggregationType.Max }),
+      ],
+      [
+        "a Sum tile over another metric",
+        makeValueTile({ metricName: "k8s.pod.cpu.usage" }),
+      ],
+      [
+        "a chart with the same title, metric and Sum",
+        { ...makeValueTile({}), componentType: "Chart" },
+      ],
+      ["a text widget", TEXT_HEADER],
+    ])("leaves %s alone", (_label: string, component: JSONObject) => {
+      expect(
+        KubernetesClusterCpuTileRepair.repair(makeConfig([component])),
+      ).toBeNull();
+    });
+
+    test.each([
+      ["undefined", undefined],
+      ["null", null],
+      ["a string", "not a config"],
+      ["an array", [makeValueTile({})]],
+      ["a config without components", { _type: "DashboardViewConfig" }],
+      [
+        "a config whose components are not an array",
+        { components: { 0: makeValueTile({}) } },
+      ],
+      ["a config with no components", makeConfig([])],
+    ])("returns null for %s", (_label: string, config: unknown) => {
+      expect(KubernetesClusterCpuTileRepair.repair(config)).toBeNull();
+    });
+
+    test("skips malformed components without throwing", () => {
+      const result: KubernetesClusterCpuTileRepairResult | null =
+        KubernetesClusterCpuTileRepair.repair(
+          makeConfig([
+            null,
+            "text",
+            42,
+            { componentType: "Value" },
+            { componentType: "Value", arguments: null },
+            {
+              componentType: "Value",
+              arguments: { title: LEGACY_CLUSTER_CPU_TILE_TITLE },
+            },
+            makeValueTile({}),
+          ]),
+        );
+
+      expect(result!.repairedTileCount).toBe(1);
+      expect(componentsOf(result!.config).slice(0, 6)).toEqual([
+        null,
+        "text",
+        42,
+        { componentType: "Value" },
+        { componentType: "Value", arguments: null },
+        {
+          componentType: "Value",
+          arguments: { title: LEGACY_CLUSTER_CPU_TILE_TITLE },
+        },
+      ]);
+    });
+  });
+
+  describe("getLegacyTileContainment", () => {
+    /*
+     * The migration reads only the dashboards Postgres matches with this
+     * document, then repairs them with isLegacyTile. If the two disagree,
+     * a dashboard is either never read or read and left unrepaired.
+     */
+    test.each([
+      ["the legacy tile", makeConfig([TEXT_HEADER, makeValueTile({})]), true],
+      [
+        "the legacy tile with user thresholds and filters",
+        makeConfig([
+          makeValueTile({
+            extraArguments: { warningThreshold: 3 },
+            extraFilterData: { attributes: { "resource.k8s.node.name": "a" } },
+          }),
+        ]),
+        true,
+      ],
+      [
+        "a repaired tile",
+        makeConfig([
+          makeValueTile({
+            title: BUSIEST_NODE_CPU_TILE_TITLE,
+            aggregation: AggregationType.Max,
+          }),
+        ]),
+        false,
+      ],
+      [
+        "the title on one tile and the Sum on another",
+        makeConfig([
+          makeValueTile({ aggregation: AggregationType.Avg }),
+          makeValueTile({ title: "All Nodes CPU" }),
+        ]),
+        false,
+      ],
+      [
+        "a chart with the legacy signature",
+        makeConfig([{ ...makeValueTile({}), componentType: "Chart" }]),
+        false,
+      ],
+      [
+        "an unrelated dashboard",
+        makeConfig([TEXT_HEADER, NETWORK_CHART]),
+        false,
+      ],
+    ])(
+      "agrees with repair() on %s",
+      (_label: string, config: JSONObject, shouldMatch: boolean) => {
+        expect(
+          jsonbContains(
+            config,
+            KubernetesClusterCpuTileRepair.getLegacyTileContainment(),
+          ),
+        ).toBe(shouldMatch);
+        expect(KubernetesClusterCpuTileRepair.repair(config) !== null).toBe(
+          shouldMatch,
+        );
+      },
+    );
+  });
+});

package/Tests/Utils/Rules/MonitorTypeRuleCriteria.test.ts

@@ -0,0 +1,181 @@
+import {
+  getMonitorTypeCriteriaValidationError,
+  isMonitorTypeCriteriaValue,
+} from "../../../Utils/Rules/MonitorTypeRuleCriteria";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import {
+  RuleCriteriaFilter,
+  RuleCriteriaOperator,
+  RuleCriteriaValue,
+} from "../../../Types/Rules/RuleCriteria";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The gate that decides whether a rule's `monitorType` criterion may be saved.
+ * DatabaseService runs it on every write and the SLO monitor-rule engine runs
+ * it again when it matches monitors, so a criterion this lets through has to
+ * be one the engine can actually evaluate: a monitor type is an enum choice,
+ * which means an exact match either way and nothing else. A text operator
+ * slipping past here is a rule that silently matches nothing.
+ */
+
+function buildFilter(
+  operator: RuleCriteriaOperator,
+  value: RuleCriteriaValue,
+): RuleCriteriaFilter {
+  return { field: "monitorType", operator: operator, value: value };
+}
+
+const OPERATOR_ERROR: string =
+  "Monitor type criteria only support Equals and Does not equal operators.";
+const VALUE_ERROR: string =
+  "Monitor type criteria require a valid monitor type.";
+
+describe("isMonitorTypeCriteriaValue", () => {
+  test("accepts every monitor type the product defines", () => {
+    const allTypes: Array<string> = Object.values(MonitorType);
+    expect(allTypes.length).toBeGreaterThan(0);
+    for (const monitorType of allTypes) {
+      expect(isMonitorTypeCriteriaValue(monitorType)).toBe(true);
+    }
+  });
+
+  test("rejects a string that is not a monitor type", () => {
+    expect(isMonitorTypeCriteriaValue("Website")).toBe(
+      Object.values(MonitorType).includes("Website" as MonitorType),
+    );
+    expect(isMonitorTypeCriteriaValue("NotAMonitorType")).toBe(false);
+    expect(isMonitorTypeCriteriaValue("")).toBe(false);
+  });
+
+  test("is case- and whitespace-sensitive, as an enum comparison must be", () => {
+    const [first] = Object.values(MonitorType) as Array<string>;
+    expect(isMonitorTypeCriteriaValue(first!)).toBe(true);
+    expect(isMonitorTypeCriteriaValue(first!.toLowerCase())).toBe(
+      first === first!.toLowerCase(),
+    );
+    expect(isMonitorTypeCriteriaValue(` ${first!}`)).toBe(false);
+    expect(isMonitorTypeCriteriaValue(`${first!} `)).toBe(false);
+  });
+
+  test("rejects every non-string value a criterion can carry", () => {
+    const nonStrings: Array<unknown> = [
+      undefined,
+      null,
+      0,
+      1,
+      true,
+      false,
+      [],
+      [Object.values(MonitorType)[0]],
+      {},
+      { value: Object.values(MonitorType)[0] },
+    ];
+    for (const value of nonStrings) {
+      expect(isMonitorTypeCriteriaValue(value)).toBe(false);
+    }
+  });
+
+  test("does not accept an inherited Object property as a monitor type", () => {
+    // The lookup is a Set, not a plain object, so "toString" is not a member.
+    expect(isMonitorTypeCriteriaValue("toString")).toBe(false);
+    expect(isMonitorTypeCriteriaValue("constructor")).toBe(false);
+    expect(isMonitorTypeCriteriaValue("__proto__")).toBe(false);
+  });
+});
+
+describe("getMonitorTypeCriteriaValidationError", () => {
+  const validType: MonitorType = Object.values(MonitorType)[0] as MonitorType;
+
+  test("passes Equals and NotEquals against a real monitor type", () => {
+    for (const operator of [
+      RuleCriteriaOperator.Equals,
+      RuleCriteriaOperator.NotEquals,
+    ]) {
+      expect(
+        getMonitorTypeCriteriaValidationError(buildFilter(operator, validType)),
+      ).toBeNull();
+    }
+  });
+
+  test("passes every monitor type under Equals", () => {
+    for (const monitorType of Object.values(MonitorType)) {
+      expect(
+        getMonitorTypeCriteriaValidationError(
+          buildFilter(RuleCriteriaOperator.Equals, monitorType),
+        ),
+      ).toBeNull();
+    }
+  });
+
+  test("rejects every operator other than Equals and NotEquals", () => {
+    const rejected: Array<RuleCriteriaOperator> = Object.values(
+      RuleCriteriaOperator,
+    ).filter((operator: RuleCriteriaOperator) => {
+      return (
+        operator !== RuleCriteriaOperator.Equals &&
+        operator !== RuleCriteriaOperator.NotEquals
+      );
+    });
+    expect(rejected.length).toBeGreaterThan(0);
+
+    for (const operator of rejected) {
+      expect(
+        getMonitorTypeCriteriaValidationError(buildFilter(operator, validType)),
+      ).toBe(OPERATOR_ERROR);
+    }
+  });
+
+  test("reports the operator first when both the operator and the value are wrong", () => {
+    expect(
+      getMonitorTypeCriteriaValidationError(
+        buildFilter(RuleCriteriaOperator.Contains, "NotAMonitorType"),
+      ),
+    ).toBe(OPERATOR_ERROR);
+  });
+
+  test("rejects a value that is not a monitor type under a supported operator", () => {
+    for (const operator of [
+      RuleCriteriaOperator.Equals,
+      RuleCriteriaOperator.NotEquals,
+    ]) {
+      expect(
+        getMonitorTypeCriteriaValidationError(
+          buildFilter(operator, "NotAMonitorType"),
+        ),
+      ).toBe(VALUE_ERROR);
+      expect(
+        getMonitorTypeCriteriaValidationError(buildFilter(operator, "")),
+      ).toBe(VALUE_ERROR);
+      /*
+       * An array is what the HasAnyOf-style operators carry; it is not a
+       * monitor type even when every member of it is one.
+       */
+      expect(
+        getMonitorTypeCriteriaValidationError(
+          buildFilter(operator, [validType]),
+        ),
+      ).toBe(VALUE_ERROR);
+      expect(
+        getMonitorTypeCriteriaValidationError(buildFilter(operator, true)),
+      ).toBe(VALUE_ERROR);
+      expect(
+        getMonitorTypeCriteriaValidationError(buildFilter(operator, 0)),
+      ).toBe(VALUE_ERROR);
+    }
+  });
+
+  test("ignores the filter's field: the caller decides which field this applies to", () => {
+    expect(
+      getMonitorTypeCriteriaValidationError({
+        field: "somethingElse",
+        operator: RuleCriteriaOperator.Equals,
+        value: validType,
+      }),
+    ).toBeNull();
+  });
+
+  test("the two errors are distinct, so a form can say which one it is", () => {
+    expect(OPERATOR_ERROR).not.toBe(VALUE_ERROR);
+  });
+});

package/Types/BaseDatabase/AggregationType.ts

@@ -15,6 +15,12 @@ enum AggregationType {
    * over the raw column, which is the right thing for scalar columns.
    */
   P50 = "P50",
+  /*
+   * The level Core Web Vitals are judged at: Google's good / poor
+   * thresholds for LCP, INP and CLS apply to the 75th percentile of page
+   * views, so a web-vital chart or monitor wants exactly this one.
+   */
+  P75 = "P75",
   P90 = "P90",
   P95 = "P95",
   P99 = "P99",
@@ -24,6 +30,7 @@ export default AggregationType;
 
 export const PercentileAggregationLevels: Record<string, number> = {
   [AggregationType.P50]: 0.5,
+  [AggregationType.P75]: 0.75,
   [AggregationType.P90]: 0.9,
   [AggregationType.P95]: 0.95,
   [AggregationType.P99]: 0.99,

package/Types/Dashboard/DashboardTemplates.ts

@@ -1742,6 +1742,18 @@ function createKubernetesDashboardConfig(): DashboardViewConfig {
    *   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".
+   *
+   * - "Cluster CPU (cores in use)" used to be a Value widget over
+   *   k8s.node.cpu.usage with `Sum` — the same trap as Pod Count. The
+   *   server sums every node's reading in each bucket and the Value widget
+   *   then sums the buckets, so a one-hour window of minute buckets and
+   *   30s kubelet scrapes read 540 for three nodes on 1.5 cores each,
+   *   instead of 4.5. A Value widget can't express "sum across nodes at one
+   *   instant", so the tile is now the busiest node's peak (`Max`), which
+   *   is honest at any window and complements the per-node average in
+   *   row 1. Cluster-wide CPU against capacity lives on the cluster
+   *   overview page. Dashboards already created from this template are
+   *   repaired by the RepairKubernetesDashboardClusterCpuTile migration.
    */
   const components: Array<DashboardBaseComponent> = [
     // Row 0: Title
@@ -1875,22 +1887,23 @@ function createKubernetesDashboardConfig(): DashboardViewConfig {
     }),
 
     /*
-     * Row 11-13: cluster CPU cores tile and the network throughput
-     * chart. This was a 0-100 CPU gauge, but the cores-valued
+     * Row 11-13: busiest-node CPU 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.
+     * real percentage. It then became a `Sum` of cores, which multiplied
+     * by the scrape count — see top-of-function comment. `Max` is the
+     * highest reading any single node reported in the window. The old
+     * "Memory Utilization" gauge over raw bytes is gone too.
      */
     createValueComponent({
-      title: "Cluster CPU (cores in use)",
+      title: "Busiest Node CPU (cores, peak)",
       top: 11,
       left: 0,
       width: 4,
       metricConfig: {
         metricName: "k8s.node.cpu.usage",
-        aggregationType: MetricsAggregationType.Sum,
+        aggregationType: MetricsAggregationType.Max,
       },
       trendDirection: DashboardValueTrendDirection.HigherIsWorse,
     }),

package/Types/Rum/SessionReplayCustomEvents.ts

@@ -215,15 +215,27 @@ export type SessionReplayWebVitalMetric =
 export type SessionReplayWebVitalRating = "good" | "needs-improvement" | "poor";
 
 /*
- * A web vital observed once per metric per page. Informational only:
- * vitals never trigger an upload, and CLS's value is unitless while the
- * others are milliseconds.
+ * How the view an INP describes began: the document load ("hard") or a
+ * single-page-app route change ("soft").
+ */
+export type SessionReplayNavigationType = "hard" | "soft";
+
+/* The input that produced an INP, as the browser classes it. */
+export type SessionReplayInteractionType = "pointer" | "keyboard";
+
+/*
+ * A web vital. LCP, FCP, CLS and TTFB are observed once per page load;
+ * INP once per VIEW (newer recorders), so a single-page app reports one
+ * INP for each route the user interacted on instead of one for the whole
+ * visit. Informational only: vitals never trigger an upload, and CLS's
+ * value is unitless while the others are milliseconds.
  */
 export interface SessionReplayWebVitalPayload {
   kind: "web-vital";
   metric: SessionReplayWebVitalMetric;
   value: number;
   rating: SessionReplayWebVitalRating;
+  /* INP: the scrubbed URL of the view the interaction happened on. */
   url?: string;
   /*
    * As on SessionReplayPerformanceBudgetPayload: when the measured entry
@@ -232,6 +244,20 @@ export interface SessionReplayWebVitalPayload {
    * after the moment the number describes. Optional for older recorders.
    */
   occurredAtUnixMs?: number;
+
+  /*
+   * INP attribution, all optional (older recorders and engines without
+   * the timing fields omit them). The three phases add up to roughly the
+   * value: waiting for the main thread, running the page's handlers, and
+   * rendering the next frame. The target is a structural selector built
+   * exactly as a click's is - never an attribute value or text.
+   */
+  navigationType?: SessionReplayNavigationType;
+  interactionType?: SessionReplayInteractionType;
+  interactionTarget?: string;
+  inputDelayMs?: number;
+  processingDurationMs?: number;
+  presentationDelayMs?: number;
 }
 
 export type SessionReplayPerformancePayload =

package/Types/Rum/WebVitals.ts

@@ -86,6 +86,19 @@ export const WebVitalDefinitions: Array<WebVitalDefinition> = [
   },
 ];
 
+/*
+ * The metric attribute that names the route a web vital was measured on,
+ * tried in order for the RUM overview's per-route breakdown. `app.route`
+ * is what the Core Web Vitals docs tell instrumentation to set;
+ * `url.template` is OpenTelemetry's semantic-convention name for the same
+ * thing. Either must hold the route PATTERN ("/products/:id"), never the
+ * concrete URL - one series per product page is a cardinality problem.
+ */
+export const WebVitalRouteAttributeKeys: Array<string> = [
+  "app.route",
+  "url.template",
+];
+
 // A threshold the way a person would say it: "2.5 s", "800 ms", "0.1".
 export function formatWebVitalThreshold(
   value: number,