@oneuptime/common 12.0.33 → 12.0.34

package/Tests/App/StatusPage/StatusPageResourceSearchBox.test.tsx

@@ -0,0 +1,224 @@
+import "@testing-library/jest-dom";
+import { fireEvent, render, screen } from "@testing-library/react";
+import React from "react";
+import { describe, expect, jest, test } from "@jest/globals";
+
+jest.mock("react-i18next", () => {
+  return {
+    useTranslation: () => {
+      return {
+        t: (
+          key: string,
+          opts?: { defaultValue?: string } & Record<string, unknown>,
+        ): string => {
+          let out: string = opts?.defaultValue ?? key;
+
+          for (const name of Object.keys(opts || {})) {
+            out = out
+              .split(`{{${name}}}`)
+              .join(String((opts as Record<string, unknown>)[name]));
+          }
+
+          return out;
+        },
+      };
+    },
+  };
+});
+
+import ResourceSearchBox from "../../../../App/FeatureSet/StatusPage/src/Components/Search/ResourceSearchBox";
+
+/*
+ * Contract under test - the field that answers "which of these is mine?".
+ *
+ * A status page with a couple of hundred resources under nested groups had no
+ * way to answer that except opening every group and reading. The field is a
+ * small thing, so what it has to get right is the small things: it has to be
+ * announced as a search, it has to say how much of the page is left after
+ * filtering (out loud, for a screen reader, not only on screen), it has to be
+ * clearable without reaching for the mouse, and clearing it has to leave the
+ * cursor where the visitor was already typing.
+ */
+
+type OnChangeMock = ReturnType<typeof jest.fn<(value: string) => void>>;
+
+function renderBox(
+  props: Partial<React.ComponentProps<typeof ResourceSearchBox>> = {},
+): { onChange: OnChangeMock } {
+  const onChange: OnChangeMock = jest.fn<(value: string) => void>();
+
+  render(
+    <ResourceSearchBox
+      value={props.value === undefined ? "" : props.value}
+      onChange={props.onChange || onChange}
+      matchedCount={props.matchedCount === undefined ? 12 : props.matchedCount}
+      totalCount={props.totalCount === undefined ? 12 : props.totalCount}
+    />,
+  );
+
+  return { onChange: onChange };
+}
+
+function input(): HTMLElement {
+  return screen.getByTestId("status-page-resource-search-input");
+}
+
+describe("ResourceSearchBox", () => {
+  test("is announced as a search landmark", () => {
+    renderBox();
+
+    expect(screen.getByRole("search")).toBeInTheDocument();
+  });
+
+  /*
+   * The field carries no visible label, so without this the only thing a
+   * screen reader has to go on is the placeholder - which is not a label.
+   */
+  test("the field has an accessible name of its own", () => {
+    renderBox();
+
+    expect(input()).toHaveAttribute("aria-label", "Search resources");
+  });
+
+  test("typing is reported to the caller", () => {
+    const { onChange } = renderBox();
+
+    fireEvent.change(input(), { target: { value: "checkout" } });
+
+    expect(onChange).toHaveBeenCalledWith("checkout");
+  });
+
+  test("the field shows what the caller says it holds", () => {
+    renderBox({ value: "checkout" });
+
+    expect(input()).toHaveValue("checkout");
+  });
+});
+
+describe("ResourceSearchBox - the result count", () => {
+  test("says how much of the page survived the query", () => {
+    renderBox({ value: "checkout", matchedCount: 3, totalCount: 42 });
+
+    expect(
+      screen.getByTestId("status-page-resource-search-count"),
+    ).toHaveTextContent("3 of 42 resources");
+  });
+
+  test("says nothing at all when nothing has been typed", () => {
+    renderBox({ value: "", matchedCount: 42, totalCount: 42 });
+
+    expect(
+      screen.getByTestId("status-page-resource-search-count"),
+    ).toHaveTextContent("");
+  });
+
+  /*
+   * Polite, not assertive: this changes on every keystroke, and an assertive
+   * region would interrupt the visitor's own typing.
+   */
+  test("the count is announced politely", () => {
+    renderBox({ value: "checkout" });
+
+    expect(
+      screen.getByTestId("status-page-resource-search-count"),
+    ).toHaveAttribute("aria-live", "polite");
+  });
+
+  test("the field points at the count so it is read with the field", () => {
+    renderBox({ value: "checkout" });
+
+    const describedBy: string | null = input().getAttribute("aria-describedby");
+
+    expect(describedBy).toBeTruthy();
+    expect(document.getElementById(describedBy as string)).toBe(
+      screen.getByTestId("status-page-resource-search-count"),
+    );
+  });
+
+  test("zero matches is still a count, not a blank", () => {
+    renderBox({ value: "kubernetes", matchedCount: 0, totalCount: 42 });
+
+    expect(
+      screen.getByTestId("status-page-resource-search-count"),
+    ).toHaveTextContent("0 of 42 resources");
+  });
+});
+
+describe("ResourceSearchBox - clearing", () => {
+  test("there is nothing to clear until something is typed", () => {
+    renderBox({ value: "" });
+
+    expect(
+      screen.queryByTestId("status-page-resource-search-clear"),
+    ).not.toBeInTheDocument();
+  });
+
+  test("a query brings out a clear control", () => {
+    renderBox({ value: "checkout" });
+
+    expect(
+      screen.getByTestId("status-page-resource-search-clear"),
+    ).toHaveAttribute("aria-label", "Clear search");
+  });
+
+  test("pressing it empties the query", () => {
+    const { onChange } = renderBox({ value: "checkout" });
+
+    fireEvent.click(screen.getByTestId("status-page-resource-search-clear"));
+
+    expect(onChange).toHaveBeenCalledWith("");
+  });
+
+  /*
+   * Clearing with the mouse and then having to click back into the field to
+   * carry on typing is the kind of small friction that makes a search feel
+   * broken.
+   */
+  test("clearing leaves the cursor in the field", () => {
+    renderBox({ value: "checkout" });
+
+    fireEvent.click(screen.getByTestId("status-page-resource-search-clear"));
+
+    expect(document.activeElement).toBe(input());
+  });
+
+  /*
+   * Escape clears rather than blurs: getting the whole page back is what a
+   * visitor wants, and a blurred field with text still in it looks like the
+   * page is stuck.
+   */
+  test("Escape clears the query", () => {
+    const { onChange } = renderBox({ value: "checkout" });
+
+    fireEvent.keyDown(input(), { key: "Escape" });
+
+    expect(onChange).toHaveBeenCalledWith("");
+  });
+
+  test("Escape on an empty field is left to the browser", () => {
+    const { onChange } = renderBox({ value: "" });
+
+    const notPrevented: boolean = fireEvent.keyDown(input(), {
+      key: "Escape",
+    });
+
+    expect(onChange).not.toHaveBeenCalled();
+    expect(notPrevented).toBe(true);
+  });
+
+  test("a query of only spaces is not treated as a query", () => {
+    renderBox({ value: "   " });
+
+    expect(
+      screen.queryByTestId("status-page-resource-search-clear"),
+    ).not.toBeInTheDocument();
+  });
+
+  test("other keys are left alone so typing still works", () => {
+    const { onChange } = renderBox({ value: "check" });
+
+    fireEvent.keyDown(input(), { key: "o" });
+
+    expect(onChange).not.toHaveBeenCalled();
+  });
+});

package/Tests/Models/AnalyticsModels/RumSessionReplayColumns.test.ts

@@ -0,0 +1,262 @@
+import { describe, expect, it, jest } from "@jest/globals";
+import fs from "fs";
+import path from "path";
+import AnalyticsBaseModel from "../../../Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
+import AnalyticsTableColumn from "../../../Types/AnalyticsDatabase/TableColumn";
+import TableColumnType from "../../../Types/AnalyticsDatabase/TableColumnType";
+import Permission from "../../../Types/Permission";
+import RumSession from "../../../Models/AnalyticsModels/RumSession";
+import RumSessionChunk from "../../../Models/AnalyticsModels/RumSessionChunk";
+import AddSessionReplayEngagementColumns from "../../../../App/FeatureSet/Workers/DataMigrations/AddSessionReplayEngagementColumns";
+
+/*
+ * The migration imports the two ClickHouse services for their column DDL
+ * helpers. Neither is exercised here (the migration is a no-op on
+ * clusters and the column assertions read the models directly), and
+ * loading them for real drags the ClickHouse client into a model test.
+ */
+jest.mock("Common/Server/Services/RumSessionService", () => {
+  return { __esModule: true, default: {} };
+});
+jest.mock("Common/Server/Services/RumSessionChunkService", () => {
+  return { __esModule: true, default: {} };
+});
+jest.mock("Common/Server/Utils/Logger", () => {
+  return {
+    __esModule: true,
+    default: { info: jest.fn(), warn: jest.fn(), error: jest.fn() },
+  };
+});
+
+/*
+ * The engagement columns added for identify()/setTags()/track() and the
+ * click recorder. Two of these decisions are privacy decisions and are
+ * pinned by identity, not by value: identifiedUserTraits describes a
+ * PERSON and must sit behind exactly the ACL object identifiedUserLabel
+ * uses, and tags describe a SESSION and must sit behind exactly the
+ * object the rest of the row uses. Sharing the object (not a copy) is
+ * what guarantees a future ACL change moves both columns together.
+ */
+
+function findColumn(
+  model: AnalyticsBaseModel,
+  key: string,
+): AnalyticsTableColumn | undefined {
+  return model.tableColumns.find((column: AnalyticsTableColumn): boolean => {
+    return column.key === key;
+  });
+}
+
+function requireColumn(
+  model: AnalyticsBaseModel,
+  key: string,
+): AnalyticsTableColumn {
+  const column: AnalyticsTableColumn | undefined = findColumn(model, key);
+
+  if (!column) {
+    throw new Error(`${model.tableName} does not declare ${key}`);
+  }
+
+  return column;
+}
+
+describe("RumSession engagement columns", () => {
+  const model: RumSession = new RumSession();
+
+  it("declares every engagement column", () => {
+    for (const key of [
+      "tags",
+      "identifiedUserTraits",
+      "clickCount",
+      "customEventCount",
+      "firstErrorOffsetMs",
+      "activeMs",
+    ]) {
+      expect(findColumn(model, key)).toBeDefined();
+    }
+  });
+
+  it("identifiedUserTraits carries the SAME ACL object as identifiedUserLabel", () => {
+    const label: AnalyticsTableColumn = requireColumn(
+      model,
+      "identifiedUserLabel",
+    );
+    const traits: AnalyticsTableColumn = requireColumn(
+      model,
+      "identifiedUserTraits",
+    );
+
+    expect(traits.accessControl).toBeDefined();
+    expect(traits.accessControl).toBe(label.accessControl);
+    /* And that object is the narrow one: no plain list permission. */
+    expect(traits.accessControl?.read).not.toContain(
+      Permission.ReadRumSessionReplay,
+    );
+    expect(traits.accessControl?.read).not.toContain(Permission.TelemetryAdmin);
+    expect(traits.accessControl?.read).toContain(
+      Permission.ReadRumSessionReplayPayload,
+    );
+  });
+
+  it("identifiedUserTraits is a Map(String, String) defaulting to {} with no skip index", () => {
+    const traits: AnalyticsTableColumn = requireColumn(
+      model,
+      "identifiedUserTraits",
+    );
+
+    expect(traits.type).toBe(TableColumnType.MapStringString);
+    expect(traits.defaultValue).toEqual({});
+    expect(traits.required).toBe(true);
+    /* Traits are never filtered on; an index would only index PII. */
+    expect(traits.skipIndex).toBeUndefined();
+  });
+
+  it("tags carries the SAME ACL object as the ordinary session columns", () => {
+    const tags: AnalyticsTableColumn = requireColumn(model, "tags");
+    const durationMs: AnalyticsTableColumn = requireColumn(model, "durationMs");
+    const errorCount: AnalyticsTableColumn = requireColumn(model, "errorCount");
+
+    expect(tags.accessControl).toBeDefined();
+    expect(tags.accessControl).toBe(durationMs.accessControl);
+    expect(tags.accessControl).toBe(errorCount.accessControl);
+    expect(tags.accessControl?.read).toContain(Permission.ReadRumSessionReplay);
+    expect(tags.type).toBe(TableColumnType.MapStringString);
+    expect(tags.defaultValue).toEqual({});
+  });
+
+  it("tags and traits are distinct columns with distinct ACLs", () => {
+    const tags: AnalyticsTableColumn = requireColumn(model, "tags");
+    const traits: AnalyticsTableColumn = requireColumn(
+      model,
+      "identifiedUserTraits",
+    );
+
+    expect(tags.accessControl).not.toBe(traits.accessControl);
+  });
+
+  it("clickCount and customEventCount are Int32 counters under the session ACL, defaulting to 0", () => {
+    for (const key of ["clickCount", "customEventCount"]) {
+      const column: AnalyticsTableColumn = requireColumn(model, key);
+      const errorCount: AnalyticsTableColumn = requireColumn(
+        model,
+        "errorCount",
+      );
+
+      expect(column.type).toBe(TableColumnType.Number);
+      expect(column.defaultValue).toBe(0);
+      expect(column.accessControl).toBe(errorCount.accessControl);
+    }
+  });
+
+  it("firstErrorOffsetMs and activeMs are Int64 (BigNumber), default 0, and never T64-coded", () => {
+    for (const key of ["firstErrorOffsetMs", "activeMs"]) {
+      const column: AnalyticsTableColumn = requireColumn(model, key);
+      const durationMs: AnalyticsTableColumn = requireColumn(
+        model,
+        "durationMs",
+      );
+
+      expect(column.type).toBe(TableColumnType.BigNumber);
+      expect(column.defaultValue).toBe(0);
+      expect(column.accessControl).toBe(durationMs.accessControl);
+
+      const codecs: Array<{ codec: string }> = Array.isArray(column.codec)
+        ? (column.codec as Array<{ codec: string }>)
+        : column.codec
+          ? [column.codec as { codec: string }]
+          : [];
+
+      expect(
+        codecs.some((codec: { codec: string }): boolean => {
+          return codec.codec === "T64";
+        }),
+      ).toBe(false);
+    }
+  });
+
+  it("the existing counters and the sort key are untouched", () => {
+    expect(requireColumn(model, "errorCount").defaultValue).toBeUndefined();
+    expect(model.sortKeys).toEqual([
+      "projectId",
+      "rumApplicationId",
+      "startTime",
+      "sessionId",
+    ]);
+  });
+});
+
+describe("RumSessionChunk engagement columns", () => {
+  const model: RumSessionChunk = new RumSessionChunk();
+
+  it("declares clickCount and customEventCount as Int32 counters defaulting to 0 under the chunk metadata ACL", () => {
+    const errorCount: AnalyticsTableColumn = requireColumn(model, "errorCount");
+
+    for (const key of ["clickCount", "customEventCount"]) {
+      const column: AnalyticsTableColumn = requireColumn(model, key);
+
+      expect(column.type).toBe(TableColumnType.Number);
+      expect(column.defaultValue).toBe(0);
+      expect(column.accessControl).toBe(errorCount.accessControl);
+      expect(column.accessControl?.read).not.toContain(Permission.Viewer);
+    }
+  });
+
+  it("already carries a per-chunk url column, so none is added", () => {
+    expect(requireColumn(model, "url").type).toBe(TableColumnType.Text);
+    expect(
+      model.tableColumns.filter((column: AnalyticsTableColumn): boolean => {
+        return column.key === "url";
+      }),
+    ).toHaveLength(1);
+  });
+
+  it("the existing counters keep no default, so a missing envelope counter is still an insert error", () => {
+    expect(requireColumn(model, "errorCount").defaultValue).toBeUndefined();
+  });
+});
+
+describe("AddSessionReplayEngagementColumns migration", () => {
+  /*
+   * Registration is pinned by reading Index.ts as text, the same way the
+   * App-side migration tests do: importing the index would instantiate
+   * every migration in the repo and their Postgres services.
+   */
+  const indexSource: string = fs.readFileSync(
+    path.resolve(
+      __dirname,
+      "../../../../App/FeatureSet/Workers/DataMigrations/Index.ts",
+    ),
+    "utf8",
+  );
+
+  it("is imported and instantiated in DataMigrations/Index.ts exactly once", () => {
+    expect(indexSource).toContain(
+      'import AddSessionReplayEngagementColumns from "./AddSessionReplayEngagementColumns";',
+    );
+    expect(
+      indexSource.split("new AddSessionReplayEngagementColumns()"),
+    ).toHaveLength(2);
+  });
+
+  it("is registered LAST in the data-migration chain", () => {
+    const instantiations: Array<string> =
+      indexSource.match(/new [A-Za-z0-9_]+\(\)/g) || [];
+
+    expect(instantiations.length).toBeGreaterThan(0);
+    expect(instantiations[instantiations.length - 1]).toBe(
+      "new AddSessionReplayEngagementColumns()",
+    );
+  });
+
+  it("does not run in cluster mode, because boot schema-sync performs the same ADD COLUMN there", () => {
+    expect(new AddSessionReplayEngagementColumns().runsInClusterMode()).toBe(
+      false,
+    );
+  });
+
+  it("names itself so the runner records it under a stable key", () => {
+    expect(new AddSessionReplayEngagementColumns().name).toBe(
+      "AddSessionReplayEngagementColumns",
+    );
+  });
+});

package/Tests/Models/CustomFieldMappingColumns.test.ts

@@ -0,0 +1,166 @@
+import { describe, expect, test } from "@jest/globals";
+import fs from "fs";
+import path from "path";
+import BaseModel from "../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import AlertCustomField from "../../Models/DatabaseModels/AlertCustomField";
+import IncidentCustomField from "../../Models/DatabaseModels/IncidentCustomField";
+import InventoryItemCustomField from "../../Models/DatabaseModels/InventoryItemCustomField";
+import MonitorCustomField from "../../Models/DatabaseModels/MonitorCustomField";
+import OnCallDutyPolicyCustomField from "../../Models/DatabaseModels/OnCallDutyPolicyCustomField";
+import ScheduledMaintenanceCustomField from "../../Models/DatabaseModels/ScheduledMaintenanceCustomField";
+import StatusPageCustomField from "../../Models/DatabaseModels/StatusPageCustomField";
+import TeamCustomField from "../../Models/DatabaseModels/TeamCustomField";
+import TeamMemberCustomField from "../../Models/DatabaseModels/TeamMemberCustomField";
+import { ColumnAccessControl } from "../../Types/BaseDatabase/AccessControl";
+import { getColumnAccessControl } from "../../Types/Database/AccessControl/ColumnAccessControl";
+import {
+  getTableColumn,
+  TableColumnMetadata,
+} from "../../Types/Database/TableColumn";
+import TableColumnType from "../../Types/Database/TableColumnType";
+
+/*
+ * The nine `*CustomField` definition tables are near-identical clones, and
+ * this test exists because ONE of them missing a column is not a small
+ * cosmetic inconsistency — it is an outage on unrelated pages.
+ *
+ * CustomFieldsDetail (the Custom Fields card on every resource) issues ONE
+ * select for whatever definition model it is handed, and SelectPermission
+ * throws BadDataException on a column the model does not declare. So adding
+ * the value-mapping columns to only the three resources that can actually use
+ * them, while asking for them in that shared select, would make the Monitor,
+ * Team, Status Page, On-Call and Inventory custom-field cards error out and
+ * their table columns and facet chips silently vanish.
+ */
+
+const MODELS_DIRECTORY: string = path.join(
+  __dirname,
+  "..",
+  "..",
+  "Models",
+  "DatabaseModels",
+);
+
+const MAPPING_COLUMNS: Array<string> = [
+  "mapFromResourceType",
+  "mapFromCustomFieldName",
+];
+
+type ModelClass = { new (): BaseModel };
+
+/*
+ * Imported statically rather than resolved by path: dynamic `require` is
+ * banned by this repo's lint config. A hand-written map is only a liability if
+ * it can fall behind the directory, which the first test below rules out — a
+ * tenth definition table fails this suite the day it is added.
+ */
+const DEFINITION_MODELS: Record<string, ModelClass> = {
+  AlertCustomField: AlertCustomField,
+  IncidentCustomField: IncidentCustomField,
+  InventoryItemCustomField: InventoryItemCustomField,
+  MonitorCustomField: MonitorCustomField,
+  OnCallDutyPolicyCustomField: OnCallDutyPolicyCustomField,
+  ScheduledMaintenanceCustomField: ScheduledMaintenanceCustomField,
+  StatusPageCustomField: StatusPageCustomField,
+  TeamCustomField: TeamCustomField,
+  TeamMemberCustomField: TeamMemberCustomField,
+};
+
+const definitionModelNames: Array<string> = fs
+  .readdirSync(MODELS_DIRECTORY)
+  .filter((fileName: string) => {
+    return fileName.endsWith("CustomField.ts");
+  })
+  .map((fileName: string) => {
+    return fileName.replace(/\.ts$/, "");
+  })
+  .sort();
+
+type LoadModelFunction = (modelName: string) => BaseModel;
+
+const loadModel: LoadModelFunction = (modelName: string): BaseModel => {
+  return new DEFINITION_MODELS[modelName]!();
+};
+
+describe("custom field definition models", () => {
+  /*
+   * Also a guard against the suite passing vacuously: if the glob stopped
+   * matching, every test.each below would silently run zero cases.
+   */
+  test("covers every definition model on disk", () => {
+    expect(definitionModelNames.length).toBeGreaterThanOrEqual(9);
+    expect(Object.keys(DEFINITION_MODELS).sort()).toEqual(definitionModelNames);
+  });
+
+  test.each(definitionModelNames)(
+    "%s declares both value-mapping columns",
+    (modelName: string) => {
+      const model: BaseModel = loadModel(modelName);
+
+      for (const columnName of MAPPING_COLUMNS) {
+        expect(Object.prototype.hasOwnProperty.call(model, columnName)).toBe(
+          true,
+        );
+
+        const tableColumn: TableColumnMetadata = getTableColumn(
+          model,
+          columnName,
+        );
+
+        expect(tableColumn).toBeTruthy();
+        expect(tableColumn.type).toBe(TableColumnType.ShortText);
+        expect(tableColumn.required).toBe(false);
+      }
+    },
+  );
+
+  /*
+   * ModelForm drops any field the user has no declared permission on, without
+   * an error. A column with no @ColumnAccessControl would therefore ship the
+   * whole feature as an invisible no-op: the settings form would simply not
+   * render the picker.
+   */
+  test.each(definitionModelNames)(
+    "%s gates both value-mapping columns with read, create and update permissions",
+    (modelName: string) => {
+      const model: BaseModel = loadModel(modelName);
+
+      for (const columnName of MAPPING_COLUMNS) {
+        const accessControl: ColumnAccessControl = getColumnAccessControl(
+          model,
+          columnName,
+        );
+
+        expect(accessControl).toBeTruthy();
+        expect(accessControl.read.length).toBeGreaterThan(0);
+        expect(accessControl.create.length).toBeGreaterThan(0);
+        expect(accessControl.update.length).toBeGreaterThan(0);
+      }
+    },
+  );
+
+  /*
+   * The mapping columns must be gated exactly as this model's other editable
+   * definition columns are — copying `dropdownOptions`' permission family is
+   * what keeps a resource's own Create/Read/Edit roles in charge of them
+   * (and is why InventoryItemCustomField correctly reuses the Telemetry
+   * family rather than minting one of its own).
+   */
+  test.each(definitionModelNames)(
+    "%s gates the value-mapping columns like its other editable columns",
+    (modelName: string) => {
+      const model: BaseModel = loadModel(modelName);
+
+      const reference: ColumnAccessControl = getColumnAccessControl(
+        model,
+        "dropdownOptions",
+      );
+
+      expect(reference).toBeTruthy();
+
+      for (const columnName of MAPPING_COLUMNS) {
+        expect(getColumnAccessControl(model, columnName)).toEqual(reference);
+      }
+    },
+  );
+});

package/Tests/Models/DatabaseModels/SessionReplayModels.test.ts

@@ -166,14 +166,21 @@ describe("RumApplication session replay configuration", () => {
     }
   });
 
-  it("is enabled by default, and still captures nothing until something happens", () => {
+  it("is enabled by default and records every session out of the box", () => {
     /*
-     * Recording is on out of the box. The thing that keeps that from meaning
-     * "record everyone continuously" is the capture trigger below: sampling
-     * stays at 0, so a session is only uploaded when it actually goes wrong.
+     * Recording is on out of the box AND sampling is 100%. The previous
+     * defaults (sample 0%, upload only on error or frustration) were the
+     * exact configuration behind issues #3527 / #3601: a customer installed
+     * the recorder, watched it buffer forever, and concluded the product was
+     * broken because a quiet day looks identical to a dead one. A customer
+     * who configures NOTHING must see a recording of their very first
+     * session; sampling down is a deliberate, visible choice made later.
+     *
+     * This test is a tripwire: a regression back to record-nothing defaults
+     * has to change this expectation and say why in the same commit.
      */
     expect(getColumn("isSessionReplayEnabled").defaultValue).toBe(true);
-    expect(getColumn("sessionReplaySamplePercentage").defaultValue).toBe(0);
+    expect(getColumn("sessionReplaySamplePercentage").defaultValue).toBe(100);
   });
 
   it("pins the shipped privacy defaults", () => {
@@ -204,8 +211,15 @@ describe("RumApplication session replay configuration", () => {
     expect(getColumn("sessionReplayConsentMode").defaultValue).toBe(
       SessionReplayConsentMode.NotRequired,
     );
+    /*
+     * Always, not OnErrorOrFrustration: with sampling at 100% (asserted
+     * above) the trigger is what decides whether a healthy session is ever
+     * uploaded, and "only broken sessions" made a working install look
+     * dead. The error/frustration trigger remains available per
+     * application for customers who want to trade coverage for bytes.
+     */
     expect(getColumn("sessionReplayCaptureTrigger").defaultValue).toBe(
-      SessionReplayCaptureTrigger.OnErrorOrFrustration,
+      SessionReplayCaptureTrigger.Always,
     );
     /*
      * Identity and country capture are ON, so a support engineer can find