@oneuptime/common 13.0.4 → 13.0.5

package/Tests/Utils/APIOutgoingRequestTracer.test.ts

@@ -0,0 +1,137 @@
+import HTTPMethod from "../../Types/API/HTTPMethod";
+import HTTPResponse from "../../Types/API/HTTPResponse";
+import URL from "../../Types/API/URL";
+import Dictionary from "../../Types/Dictionary";
+import { JSONObject } from "../../Types/JSON";
+import API, { OutgoingRequest } from "../../Utils/API";
+import { afterEach, describe, expect, jest, test } from "@jest/globals";
+import axios, { AxiosRequestConfig, AxiosStatic } from "axios";
+
+/*
+ * The shared API client stays tracing-SDK free: a server process installs an
+ * OutgoingRequestTracer, and the client must route each logical request —
+ * retries included — through it and send whatever headers it added, without
+ * disturbing the caller's own headers.
+ */
+
+jest.mock("axios", () => {
+  return Object.assign(jest.fn(), jest.requireActual("axios"));
+});
+
+const mockedAxios: jest.MockedFunction<AxiosStatic> =
+  axios as jest.MockedFunction<typeof axios>;
+
+function okResponse(): unknown {
+  return {
+    data: { ok: true },
+    status: 200,
+    statusText: "OK",
+    headers: {},
+    config: { headers: {} },
+  };
+}
+
+afterEach(() => {
+  API.setOutgoingRequestTracer(null);
+  mockedAxios.mockReset();
+});
+
+describe("API outgoing request tracer", () => {
+  test("without a tracer the request goes out exactly as configured", async () => {
+    mockedAxios.mockResolvedValueOnce(okResponse() as never);
+    await API.post<JSONObject>({
+      url: URL.fromString("https://hooks.example.com/services/T0/B0/secret"),
+      data: { text: "hi" },
+      headers: { "X-Signature": "abc" },
+    });
+    const config: AxiosRequestConfig = mockedAxios.mock
+      .calls[0]![0] as AxiosRequestConfig;
+    expect(config.headers).toEqual({
+      Accept: "application/json",
+      "Content-Type": "application/json;charset=UTF-8",
+      "X-Signature": "abc",
+    });
+  });
+
+  test("a tracer sees one request per call and its headers are sent", async () => {
+    const seen: Array<{ method: HTTPMethod; url: string }> = [];
+    API.setOutgoingRequestTracer({
+      trace: async <T>(
+        request: OutgoingRequest,
+        send: () => Promise<T>,
+      ): Promise<T> => {
+        seen.push({ method: request.method, url: request.url });
+        request.headers["traceparent"] =
+          "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01";
+        return send();
+      },
+    });
+    mockedAxios
+      .mockRejectedValueOnce(new Error("socket hang up") as never)
+      .mockResolvedValueOnce(okResponse() as never);
+
+    const response: unknown = await API.post<JSONObject>({
+      url: URL.fromString("http://oneuptime-app:3002/probe-ingest/alive"),
+      data: {},
+      headers: { "X-Probe-Key": "key" },
+      options: { retries: 1 },
+    });
+
+    expect(response).toBeInstanceOf(HTTPResponse);
+    expect(seen).toEqual([
+      {
+        method: HTTPMethod.POST,
+        url: "http://oneuptime-app:3002/probe-ingest/alive",
+      },
+    ]);
+    expect(mockedAxios).toHaveBeenCalledTimes(2);
+    for (const call of mockedAxios.mock.calls) {
+      const headers: Dictionary<string> = (call[0] as AxiosRequestConfig)
+        .headers as Dictionary<string>;
+      expect(headers["X-Probe-Key"]).toBe("key");
+      expect(headers["traceparent"]).toBe(
+        "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01",
+      );
+    }
+  });
+
+  test("a tracer that adds nothing leaves the caller's headers alone", async () => {
+    API.setOutgoingRequestTracer({
+      trace: <T>(
+        _request: OutgoingRequest,
+        send: () => Promise<T>,
+      ): Promise<T> => {
+        return send();
+      },
+    });
+    mockedAxios.mockResolvedValueOnce(okResponse() as never);
+    await API.get<JSONObject>({
+      url: URL.fromString("https://customer.example.com/health"),
+      headers: { Authorization: "Bearer customer" },
+    });
+    const headers: Dictionary<string> = (
+      mockedAxios.mock.calls[0]![0] as AxiosRequestConfig
+    ).headers as Dictionary<string>;
+    expect(headers["traceparent"]).toBeUndefined();
+    expect(headers["Authorization"]).toBe("Bearer customer");
+  });
+
+  test("the tracer learns the dispatch URL a guarded caller actually uses", async () => {
+    let tracedUrl: string = "";
+    API.setOutgoingRequestTracer({
+      trace: <T>(
+        request: OutgoingRequest,
+        send: () => Promise<T>,
+      ): Promise<T> => {
+        tracedUrl = request.url;
+        return send();
+      },
+    });
+    mockedAxios.mockResolvedValueOnce(okResponse() as never);
+    await API.get<JSONObject>({
+      url: URL.fromString("https://example.com/a"),
+      options: { dispatchUrl: "https://93.184.216.34/a" },
+    });
+    expect(tracedUrl).toBe("https://93.184.216.34/a");
+  });
+});

package/Tests/Utils/Rum/SessionReplayHealthDiagnosis.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it } from "@jest/globals";
 import {
   SESSION_REPLAY_REFUSAL_ALERT_THRESHOLD,
   SESSION_REPLAY_STALE_CHUNK_MS,
+  describeRefusalReason,
   diagnoseRecordingHealth,
   formatBytesForCopy,
   formatCountForCopy,
@@ -991,3 +992,42 @@ describe("SessionReplayRefusalReason", () => {
     expect(isSessionReplayRefusalReason(42)).toBe(false);
   });
 });
+
+describe("describeRefusalReason", () => {
+  it("has human copy for every reason in the gate's vocabulary, never the slug itself", () => {
+    for (const reason of SESSION_REPLAY_REFUSAL_REASONS) {
+      const label: string | null = describeRefusalReason(reason);
+
+      expect({ reason, hasLabel: typeof label === "string" }).toEqual({
+        reason,
+        hasLabel: true,
+      });
+      expect(label).not.toBe(reason);
+      expect((label as string).length).toBeGreaterThan(0);
+    }
+  });
+
+  it("reads the same words the diagnosis title uses", () => {
+    expect(describeRefusalReason("origin-not-allowed")).toBe(
+      "origin not allowed",
+    );
+    expect(describeRefusalReason("consent-required")).toBe(
+      "consent was not granted",
+    );
+
+    const diagnosis: RecordingHealthDiagnosis = diagnose(
+      healthy({
+        refusalsLast24h: [{ reason: "rate-limited", count: 40 }],
+      }),
+    );
+
+    expect(diagnosis.title).toContain(
+      describeRefusalReason("rate-limited") as string,
+    );
+  });
+
+  it("is null for a reason this build has no copy for (a worker drop reason, a newer gate)", () => {
+    expect(describeRefusalReason("scrub-incomplete")).toBeNull();
+    expect(describeRefusalReason("")).toBeNull();
+  });
+});