@oneuptime/common 14.0.1 → 14.0.3

package/Tests/UI/Components/UseHistogramZoom.test.tsx

@@ -8,7 +8,7 @@ import InBetween from "../../../Types/BaseDatabase/InBetween";
 import RangeStartAndEndDateTime from "../../../Types/Time/RangeStartAndEndDateTime";
 import TimeRange from "../../../Types/Time/TimeRange";
 import { act, cleanup, renderHook } from "@testing-library/react";
-import { afterEach, describe, expect, test } from "@jest/globals";
+import { afterEach, describe, expect, jest, test } from "@jest/globals";
 import getJestMockFunction, { MockFunction } from "../../MockType";
 
 const PAST_HOUR: RangeStartAndEndDateTime = { range: TimeRange.PAST_ONE_HOUR };
@@ -210,6 +210,94 @@ describe("useHistogramZoom", () => {
     });
   });
 
+  /*
+   * The newest bar is usually still filling up, and the last bar of a fixed
+   * window can reach past its end. Zooming into either whole would open a
+   * window ending in the future, or one holding rows the bar never counted.
+   */
+  describe("keeping a zoom inside the window it zooms out of", () => {
+    const FIXED_WINDOW: RangeStartAndEndDateTime = customRange(
+      "2026-08-05T10:07:23Z",
+      "2026-08-05T12:52:10Z",
+    );
+
+    function selectOn(
+      timeRange: RangeStartAndEndDateTime,
+      start: string,
+      end: string,
+    ): Array<string> {
+      const harness: ZoomHarness = renderZoom(timeRange);
+
+      act(() => {
+        harness.result.current.onTimeRangeSelect?.(
+          new Date(start),
+          new Date(end),
+        );
+      });
+
+      const [selectedStart, selectedEnd] = harness.onTimeRangeSelect.mock
+        .calls[0] as [Date, Date];
+
+      return [selectedStart.toISOString(), selectedEnd.toISOString()];
+    }
+
+    test("stops a bar that runs past the window's end at that end", () => {
+      expect(
+        selectOn(FIXED_WINDOW, "2026-08-05T12:45:00Z", "2026-08-05T13:00:00Z"),
+      ).toEqual(["2026-08-05T12:45:00.000Z", "2026-08-05T12:52:10.000Z"]);
+    });
+
+    test("leaves a selection that ends inside the window as it is", () => {
+      expect(
+        selectOn(FIXED_WINDOW, "2026-08-05T11:00:00Z", "2026-08-05T11:15:00Z"),
+      ).toEqual(["2026-08-05T11:00:00.000Z", "2026-08-05T11:15:00.000Z"]);
+    });
+
+    /*
+     * A relative window's start slides forward with the clock while the
+     * chart drawn a few minutes earlier stays put; cutting the first bar to
+     * the current start would take rows away from a bar still on screen.
+     */
+    test("leaves the start of the first bar alone", () => {
+      expect(
+        selectOn(FIXED_WINDOW, "2026-08-05T10:00:00Z", "2026-08-05T10:15:00Z"),
+      ).toEqual(["2026-08-05T10:00:00.000Z", "2026-08-05T10:15:00.000Z"]);
+    });
+
+    test("does not empty a selection the window has already moved past", () => {
+      expect(
+        selectOn(FIXED_WINDOW, "2026-08-05T13:00:00Z", "2026-08-05T13:15:00Z"),
+      ).toEqual(["2026-08-05T13:00:00.000Z", "2026-08-05T13:15:00.000Z"]);
+    });
+
+    test("stops the newest bar of a relative window at now", () => {
+      jest.useFakeTimers();
+      jest.setSystemTime(new Date("2026-08-05T12:52:10Z"));
+
+      try {
+        expect(
+          selectOn(PAST_HOUR, "2026-08-05T12:45:00Z", "2026-08-05T13:00:00Z"),
+        ).toEqual(["2026-08-05T12:45:00.000Z", "2026-08-05T12:52:10.000Z"]);
+      } finally {
+        jest.useRealTimers();
+      }
+    });
+
+    test("still remembers the window to zoom back out to", () => {
+      const harness: ZoomHarness = renderZoom(FIXED_WINDOW);
+
+      act(() => {
+        harness.result.current.onTimeRangeSelect?.(
+          new Date("2026-08-05T12:45:00Z"),
+          new Date("2026-08-05T13:00:00Z"),
+        );
+      });
+      harness.zoomOut();
+
+      expect(harness.onTimeRangeChange).toHaveBeenCalledWith(FIXED_WINDOW);
+    });
+  });
+
   describe("hosts that wire up only part of this", () => {
     test("a host with no time range gets no zoom-out to offer", () => {
       const onTimeRangeSelect: MockFunction = getJestMockFunction();

package/Tests/UI/Components/UseLogsHistogram.test.tsx

@@ -1,5 +1,6 @@
 import useLogsHistogram, {
   FetchHistogramBucketsFunction,
+  LogsHistogramData,
   LogsHistogramState,
 } from "../../../UI/Components/LogsViewer/useLogsHistogram";
 import { HistogramBucket } from "../../../UI/Components/LogsViewer/types";
@@ -56,10 +57,15 @@ const HistogramProbe: FunctionComponent<ProbeProps> = (
           .join(",")}
       </span>
       <span data-testid="loading">{String(state.isLoading)}</span>
+      <span data-testid="interval">{String(state.bucketIntervalMs)}</span>
     </div>
   );
 };
 
+function interval(): string {
+  return screen.getByTestId("interval").textContent || "";
+}
+
 function counts(): string {
   return screen.getByTestId("counts").textContent || "";
 }
@@ -289,6 +295,175 @@ describe("useLogsHistogram", () => {
     });
   });
 
+  /*
+   * The width of a bucket is what lets a click on a bar open that bar's logs
+   * (issue #3914). It has to travel with the buckets it describes: pairing
+   * one window's bars with another window's width would open the wrong span
+   * of time.
+   */
+  describe("bucket width", () => {
+    const MINUTE_MS: number = 60 * 1000;
+
+    test("is handed on with the buckets when the query reports it", async () => {
+      const fetchBuckets: FetchHistogramBucketsFunction =
+        async (): Promise<LogsHistogramData> => {
+          return { buckets: FIRST_WINDOW, bucketIntervalMs: MINUTE_MS };
+        };
+
+      render(<HistogramProbe fetchBuckets={fetchBuckets} />);
+
+      await waitFor(() => {
+        expect(counts()).toBe("11:59=3");
+      });
+
+      expect(interval()).toBe(String(MINUTE_MS));
+    });
+
+    test("is unknown for a query that returns bare buckets", async () => {
+      const fetchBuckets: FetchHistogramBucketsFunction = async (): Promise<
+        Array<HistogramBucket>
+      > => {
+        return FIRST_WINDOW;
+      };
+
+      render(<HistogramProbe fetchBuckets={fetchBuckets} />);
+
+      await waitFor(() => {
+        expect(counts()).toBe("11:59=3");
+      });
+
+      expect(interval()).toBe("undefined");
+    });
+
+    test("follows the query to a new window", async () => {
+      let answer: LogsHistogramData = {
+        buckets: FIRST_WINDOW,
+        bucketIntervalMs: MINUTE_MS,
+      };
+
+      const fetchBuckets: FetchHistogramBucketsFunction =
+        async (): Promise<LogsHistogramData> => {
+          return answer;
+        };
+
+      const view: ReturnType<typeof render> = render(
+        <HistogramProbe fetchBuckets={fetchBuckets} queryKey="one-hour" />,
+      );
+
+      await waitFor(() => {
+        expect(interval()).toBe(String(MINUTE_MS));
+      });
+
+      answer = { buckets: SECOND_WINDOW, bucketIntervalMs: 15 * MINUTE_MS };
+
+      view.rerender(
+        <HistogramProbe fetchBuckets={fetchBuckets} queryKey="one-day" />,
+      );
+
+      await waitFor(() => {
+        expect(counts()).toBe("11:59=3,12:00=8");
+      });
+
+      expect(interval()).toBe(String(15 * MINUTE_MS));
+    });
+
+    test("is dropped with the buckets when a load fails", async () => {
+      let shouldFail: boolean = false;
+
+      const fetchBuckets: FetchHistogramBucketsFunction =
+        async (): Promise<LogsHistogramData> => {
+          if (shouldFail) {
+            throw new Error("clickhouse timeout");
+          }
+
+          return { buckets: FIRST_WINDOW, bucketIntervalMs: MINUTE_MS };
+        };
+
+      render(
+        <HistogramProbe fetchBuckets={fetchBuckets} onReady={captureState} />,
+      );
+
+      await waitFor(() => {
+        expect(interval()).toBe(String(MINUTE_MS));
+      });
+
+      shouldFail = true;
+      await refresh(false);
+
+      expect(counts()).toBe("");
+      expect(interval()).toBe("undefined");
+    });
+
+    test("stays with the buckets still on screen when a poll fails", async () => {
+      let shouldFail: boolean = false;
+
+      const fetchBuckets: FetchHistogramBucketsFunction =
+        async (): Promise<LogsHistogramData> => {
+          if (shouldFail) {
+            throw new Error("clickhouse timeout");
+          }
+
+          return { buckets: FIRST_WINDOW, bucketIntervalMs: MINUTE_MS };
+        };
+
+      render(
+        <HistogramProbe fetchBuckets={fetchBuckets} onReady={captureState} />,
+      );
+
+      await waitFor(() => {
+        expect(interval()).toBe(String(MINUTE_MS));
+      });
+
+      shouldFail = true;
+      await refresh(true);
+
+      expect(counts()).toBe("11:59=3");
+      expect(interval()).toBe(String(MINUTE_MS));
+    });
+
+    test("is not overwritten by the answer to a query the reader has left", async () => {
+      const pending: Array<(data: LogsHistogramData) => void> = [];
+
+      const fetchBuckets: FetchHistogramBucketsFunction =
+        (): Promise<LogsHistogramData> => {
+          return new Promise<LogsHistogramData>(
+            (resolve: (data: LogsHistogramData) => void) => {
+              pending.push(resolve);
+            },
+          );
+        };
+
+      const view: ReturnType<typeof render> = render(
+        <HistogramProbe fetchBuckets={fetchBuckets} queryKey="one-day" />,
+      );
+
+      await waitFor(() => {
+        expect(pending.length).toBe(1);
+      });
+
+      view.rerender(
+        <HistogramProbe fetchBuckets={fetchBuckets} queryKey="one-hour" />,
+      );
+
+      await waitFor(() => {
+        expect(pending.length).toBe(2);
+      });
+
+      await act(async () => {
+        pending[1]!({ buckets: SECOND_WINDOW, bucketIntervalMs: MINUTE_MS });
+      });
+      await act(async () => {
+        pending[0]!({
+          buckets: FIRST_WINDOW,
+          bucketIntervalMs: 15 * MINUTE_MS,
+        });
+      });
+
+      expect(counts()).toBe("11:59=3,12:00=8");
+      expect(interval()).toBe(String(MINUTE_MS));
+    });
+  });
+
   /*
    * Live mode polls the histogram every few seconds. These are the properties
    * that keep the chart from flashing, blanking or stampeding while it does.

package/Tests/UI/Monitor/MonitorSummarySnapshotRender.test.tsx

@@ -275,10 +275,10 @@ describe("A stored monitor summary renders the check that caused the incident",
 
   it("does not tell the reader to wait a few minutes for data that is already here", () => {
     /*
-     * SummaryInfo's empty state for a probeable monitor is "No summary
-     * available for the selected probe. Should be few minutes for summary
-     * to show up." On an incident from last quarter that is nonsense, and
-     * it is exactly what a bare (unwrapped) probe response produces.
+     * SummaryInfo's empty state for a probeable monitor is "{probe} has not
+     * reported a result yet. Results usually appear within a few minutes of
+     * its next check." On an incident from last quarter that is nonsense,
+     * and it is exactly what a bare (unwrapped) probe response produces.
      */
     renderSnapshot(
       storeAndReadBack({
@@ -296,7 +296,7 @@ describe("A stored monitor summary renders the check that caused the incident",
       }),
     );
 
-    expect(screen.queryByText(/few minutes for summary/)).toBeNull();
+    expect(screen.queryByText(/has not reported a result yet/)).toBeNull();
     expect(screen.getByText("Host unreachable")).toBeInTheDocument();
   });
 });

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

@@ -11,7 +11,8 @@ import PrivacySummaryCard, {
  * Five sentences that say what a recording contains for the person being
  * recorded, one per masking / identity / location / retention / consent
  * choice, each with a "Change" link; a field that was never set reads as
- * the default it actually is.
+ * the default it actually is. A sixth ("backend-link") joins them while
+ * same-origin trace propagation is on, which is the default.
  */
 
 function sentence(
@@ -29,23 +30,40 @@ function sentence(
   return found as PrivacySummarySentence;
 }
 
-describe("buildPrivacySummary", () => {
-  it("always produces exactly five sentences in the reviewer's order", () => {
-    const keys: Array<string> = buildPrivacySummary({}).map(
-      (entry: PrivacySummarySentence): string => {
-        return entry.key;
-      },
-    );
+function keysOf(sentences: Array<PrivacySummarySentence>): Array<string> {
+  return sentences.map((entry: PrivacySummarySentence): string => {
+    return entry.key;
+  });
+}
 
-    expect(keys).toEqual([
+describe("buildPrivacySummary", () => {
+  it("produces six sentences in the reviewer's order while same-origin trace propagation is on (the default)", () => {
+    expect(keysOf(buildPrivacySummary({}))).toEqual([
       "page-text",
       "identity",
+      "backend-link",
+      "location",
+      "retention",
+      "consent",
+    ]);
+    expect(
+      keysOf(buildPrivacySummary({ sameOriginTracePropagation: true })),
+    ).toEqual([
+      "page-text",
+      "identity",
+      "backend-link",
       "location",
       "retention",
       "consent",
     ]);
   });
 
+  it("produces exactly the five sentences when same-origin trace propagation is off", () => {
+    expect(
+      keysOf(buildPrivacySummary({ sameOriginTracePropagation: false })),
+    ).toEqual(["page-text", "identity", "location", "retention", "consent"]);
+  });
+
   it("an empty policy reads as the model defaults and marks every sentence default", () => {
     const sentences: Array<PrivacySummarySentence> = buildPrivacySummary({});
 
@@ -105,6 +123,103 @@ describe("buildPrivacySummary", () => {
     ).toContain("least private mode");
   });
 
+  /*
+   * Same-origin trace propagation puts the session id on the page's own
+   * requests. The sentence says where it goes (the backend and every
+   * service it calls) and what that means (backend telemetry naming the
+   * user leads to the recording), and is flagged for a second look.
+   */
+  it("backend link on reads as the session id reaching the backend and beyond, and is flagged", () => {
+    const on: PrivacySummarySentence = sentence(
+      buildPrivacySummary({ sameOriginTracePropagation: true }),
+      "backend-link",
+    );
+
+    expect(on.text).toContain(
+      "Same-origin requests carry this session's id to your backend",
+    );
+    expect(on.text).toContain("forwards it to the services it calls");
+    expect(on.text).toContain("third parties included");
+    expect(on.text).toContain(
+      "Backend telemetry that names the user links to the recording",
+    );
+    expect(on.text).toContain("The visitor id is never sent");
+    expect(on.isSensitive).toBe(true);
+    expect(on.isDefault).toBe(false);
+    expect(on.changeLabel).toBe("Change trace propagation");
+  });
+
+  it("a never-set switch reads as the on default and says so", () => {
+    for (const value of [undefined, null]) {
+      const backendLink: PrivacySummarySentence = sentence(
+        buildPrivacySummary({ sameOriginTracePropagation: value }),
+        "backend-link",
+      );
+
+      expect(backendLink.isDefault).toBe(true);
+      expect(backendLink.isSensitive).toBe(true);
+    }
+  });
+
+  /*
+   * With identity capture off the recording stores no user reference, but
+   * a linked backend span or log that names the user still leads to it, so
+   * "cannot be found by who the person was" would overpromise.
+   */
+  it("identity off with the backend link on does not promise the session cannot be found by who the person was", () => {
+    const identity: PrivacySummarySentence = sentence(
+      buildPrivacySummary({
+        captureUserIdentity: false,
+        sameOriginTracePropagation: true,
+      }),
+      "identity",
+    );
+
+    expect(identity.text).toContain("pseudonymous");
+    expect(identity.text).toContain(
+      "Backend telemetry linked to it by same-origin trace propagation can still name the person",
+    );
+    expect(identity.text).not.toContain(
+      "cannot be found by who the person was",
+    );
+    expect(identity.isSensitive).toBe(false);
+
+    /* The never-set switch is the on default, so the caveat applies there too. */
+    expect(
+      sentence(buildPrivacySummary({ captureUserIdentity: false }), "identity")
+        .text,
+    ).toContain("can still name the person");
+  });
+
+  it("identity off with the backend link off keeps the full pseudonymity promise", () => {
+    const identity: PrivacySummarySentence = sentence(
+      buildPrivacySummary({
+        captureUserIdentity: false,
+        sameOriginTracePropagation: false,
+      }),
+      "identity",
+    );
+
+    expect(identity.text).toContain(
+      "so a session cannot be found by who the person was",
+    );
+    expect(identity.text).not.toContain("Backend telemetry");
+  });
+
+  it("identity on is unchanged by the backend link", () => {
+    for (const value of [true, false]) {
+      expect(
+        sentence(
+          buildPrivacySummary({
+            captureUserIdentity: true,
+            sameOriginTracePropagation: value,
+          }),
+          "identity",
+        ).text,
+      ).toContain("Recordings are identified");
+    }
+  });
+
   it("identity off reads as pseudonymous and is not flagged", () => {
     const off: PrivacySummarySentence = sentence(
       buildPrivacySummary({ captureUserIdentity: false }),
@@ -192,6 +307,48 @@ describe("buildPrivacySummary", () => {
 });
 
 describe("PrivacySummaryCard", () => {
+  it("renders the backend-link row with its Change link while same-origin trace propagation is on", () => {
+    render(
+      <PrivacySummaryCard
+        policy={{ sameOriginTracePropagation: true }}
+        changeHref="#replay-policy"
+      />,
+    );
+
+    expect(
+      screen.getByTestId("privacy-summary-backend-link"),
+    ).toHaveTextContent(
+      "Same-origin requests carry this session's id to your backend",
+    );
+    expect(screen.getByTestId("privacy-summary-backend-link")).toHaveAttribute(
+      "data-default",
+      "false",
+    );
+    expect(
+      screen.getByTestId("privacy-summary-change-backend-link"),
+    ).toHaveAttribute("href", "#replay-policy");
+    expect(
+      screen.getByTestId("privacy-summary-change-backend-link"),
+    ).toHaveTextContent("Change trace propagation");
+  });
+
+  it("renders no backend-link row when same-origin trace propagation is off", () => {
+    render(
+      <PrivacySummaryCard
+        policy={{
+          sameOriginTracePropagation: false,
+          captureUserIdentity: false,
+        }}
+        changeHref="#replay-policy"
+      />,
+    );
+
+    expect(screen.queryByTestId("privacy-summary-backend-link")).toBeNull();
+    expect(screen.getByTestId("privacy-summary-identity")).toHaveTextContent(
+      "cannot be found by who the person was",
+    );
+  });
+
   it("renders five rows, each with a Change link to the policy anchor, and marks defaults", () => {
     render(
       <PrivacySummaryCard