@oneuptime/common 12.0.18 → 12.0.19

package/Tests/Server/Utils/Telemetry/AppMetrics.test.ts

@@ -0,0 +1,275 @@
+import { describe, expect, jest, test } from "@jest/globals";
+
+/*
+ * AppMetrics is the single catalog of self-observability instruments the
+ * OneUptime services emit. Dashboards and alerts are wired to these metric
+ * NAMES and UNITS, so a rename or a unit change here silently breaks them —
+ * these tests pin the catalog. They also pin the lazy-create-once caching the
+ * module promises (importing it from many call sites must not register the
+ * same instrument twice).
+ */
+
+jest.mock("../../../../Server/Utils/Telemetry", () => {
+  return {
+    __esModule: true,
+    default: {
+      getCounter: jest.fn((data: { name: string; unit: string }) => {
+        return { __kind: "counter", ...data };
+      }),
+      getHistogram: jest.fn((data: { name: string; unit: string }) => {
+        return { __kind: "histogram", ...data };
+      }),
+      getGauge: jest.fn((data: { name: string; unit: string }) => {
+        return { __kind: "gauge", ...data };
+      }),
+    },
+  };
+});
+
+type Factory = "getCounter" | "getHistogram" | "getGauge";
+
+interface Instrument {
+  getter: string;
+  factory: Factory;
+  kind: string;
+  name: string;
+  unit: string;
+}
+
+/*
+ * The expected catalog, mirrored from AppMetrics. Kept as data so a new
+ * instrument (or a changed name/unit) has to be reflected here deliberately.
+ */
+const CATALOG: Array<Instrument> = [
+  {
+    getter: "getHttpRequestCounter",
+    factory: "getCounter",
+    kind: "counter",
+    name: "http.server.request.count",
+    unit: "1",
+  },
+  {
+    getter: "getHttpRequestDuration",
+    factory: "getHistogram",
+    kind: "histogram",
+    name: "http.server.request.duration",
+    unit: "ms",
+  },
+  {
+    getter: "getHttpRequestsInFlight",
+    factory: "getGauge",
+    kind: "gauge",
+    name: "http.server.active_requests",
+    unit: "1",
+  },
+  {
+    getter: "getWorkerJobCounter",
+    factory: "getCounter",
+    kind: "counter",
+    name: "worker.job.count",
+    unit: "1",
+  },
+  {
+    getter: "getWorkerJobDuration",
+    factory: "getHistogram",
+    kind: "histogram",
+    name: "worker.job.duration",
+    unit: "ms",
+  },
+  {
+    getter: "getWorkerJobsInFlight",
+    factory: "getGauge",
+    kind: "gauge",
+    name: "worker.job.active",
+    unit: "1",
+  },
+  {
+    getter: "getProbeCheckCounter",
+    factory: "getCounter",
+    kind: "counter",
+    name: "probe.monitor.check.count",
+    unit: "1",
+  },
+  {
+    getter: "getProbeCheckDuration",
+    factory: "getHistogram",
+    kind: "histogram",
+    name: "probe.monitor.check.duration",
+    unit: "ms",
+  },
+  {
+    getter: "getNotificationCounter",
+    factory: "getCounter",
+    kind: "counter",
+    name: "notification.send.count",
+    unit: "1",
+  },
+  {
+    getter: "getNotificationDuration",
+    factory: "getHistogram",
+    kind: "histogram",
+    name: "notification.send.duration",
+    unit: "ms",
+  },
+  {
+    getter: "getIngestCounter",
+    factory: "getCounter",
+    kind: "counter",
+    name: "telemetry.ingest.request.count",
+    unit: "1",
+  },
+  {
+    getter: "getIngestDuration",
+    factory: "getHistogram",
+    kind: "histogram",
+    name: "telemetry.ingest.request.duration",
+    unit: "ms",
+  },
+  {
+    getter: "getIngestPayloadBytes",
+    factory: "getHistogram",
+    kind: "histogram",
+    name: "telemetry.ingest.request.payload.size",
+    unit: "By",
+  },
+  {
+    getter: "getIngestDroppedCounter",
+    factory: "getCounter",
+    kind: "counter",
+    name: "oneuptime.telemetry.ingest.dropped.count",
+    unit: "1",
+  },
+];
+
+interface LoadedModules {
+  Telemetry: {
+    getCounter: jest.Mock;
+    getHistogram: jest.Mock;
+    getGauge: jest.Mock;
+  };
+  // A catalog of no-arg getters returning tagged fake instruments.
+  AppMetrics: Record<string, () => { __kind: string; name: string }>;
+}
+
+/*
+ * Re-import with a cleared module registry so AppMetrics' static instrument
+ * cache starts empty and the mocked Telemetry factories start with a clean
+ * call history — required to assert "created exactly once".
+ */
+async function loadFresh(): Promise<LoadedModules> {
+  jest.resetModules();
+
+  const Telemetry: LoadedModules["Telemetry"] = (
+    (await import("../../../../Server/Utils/Telemetry")) as unknown as {
+      default: LoadedModules["Telemetry"];
+    }
+  ).default;
+
+  const AppMetrics: LoadedModules["AppMetrics"] = (
+    (await import(
+      "../../../../Server/Utils/Telemetry/AppMetrics"
+    )) as unknown as { default: LoadedModules["AppMetrics"] }
+  ).default;
+
+  return { Telemetry, AppMetrics };
+}
+
+describe("AppMetrics catalog", () => {
+  test.each(CATALOG)(
+    "$getter creates $name via $factory with unit $unit",
+    async (entry: Instrument) => {
+      const { Telemetry, AppMetrics } = await loadFresh();
+
+      const instrument: { __kind: string; name: string } =
+        AppMetrics[entry.getter]!();
+
+      expect(Telemetry[entry.factory]).toHaveBeenCalledTimes(1);
+      expect(Telemetry[entry.factory]).toHaveBeenCalledWith(
+        expect.objectContaining({ name: entry.name, unit: entry.unit }),
+      );
+      expect(instrument.__kind).toBe(entry.kind);
+      expect(instrument.name).toBe(entry.name);
+    },
+  );
+
+  test.each(CATALOG)(
+    "$getter lazily creates the instrument only once and caches it",
+    async (entry: Instrument) => {
+      const { Telemetry, AppMetrics } = await loadFresh();
+
+      const first: unknown = AppMetrics[entry.getter]!();
+      const second: unknown = AppMetrics[entry.getter]!();
+      const third: unknown = AppMetrics[entry.getter]!();
+
+      // Same instance handed back every time.
+      expect(second).toBe(first);
+      expect(third).toBe(first);
+
+      // The factory ran exactly once despite three getter calls.
+      const totalFactoryCalls: number =
+        Telemetry.getCounter.mock.calls.length +
+        Telemetry.getHistogram.mock.calls.length +
+        Telemetry.getGauge.mock.calls.length;
+      expect(totalFactoryCalls).toBe(1);
+    },
+  );
+
+  test("no getter accidentally routes through the wrong factory", async () => {
+    const { Telemetry, AppMetrics } = await loadFresh();
+
+    for (const entry of CATALOG) {
+      AppMetrics[entry.getter]!();
+    }
+
+    const counterNames: Array<string> = Telemetry.getCounter.mock.calls.map(
+      (c: Array<{ name: string }>) => {
+        return c[0]!.name;
+      },
+    );
+    const histogramNames: Array<string> = Telemetry.getHistogram.mock.calls.map(
+      (c: Array<{ name: string }>) => {
+        return c[0]!.name;
+      },
+    );
+    const gaugeNames: Array<string> = Telemetry.getGauge.mock.calls.map(
+      (c: Array<{ name: string }>) => {
+        return c[0]!.name;
+      },
+    );
+
+    expect(counterNames.sort()).toEqual(
+      CATALOG.filter((e: Instrument) => {
+        return e.kind === "counter";
+      })
+        .map((e: Instrument) => {
+          return e.name;
+        })
+        .sort(),
+    );
+    expect(histogramNames.sort()).toEqual(
+      CATALOG.filter((e: Instrument) => {
+        return e.kind === "histogram";
+      })
+        .map((e: Instrument) => {
+          return e.name;
+        })
+        .sort(),
+    );
+    expect(gaugeNames.sort()).toEqual(
+      CATALOG.filter((e: Instrument) => {
+        return e.kind === "gauge";
+      })
+        .map((e: Instrument) => {
+          return e.name;
+        })
+        .sort(),
+    );
+  });
+
+  test("every metric name in the catalog is unique", () => {
+    const names: Array<string> = CATALOG.map((e: Instrument) => {
+      return e.name;
+    });
+    expect(new Set(names).size).toBe(names.length);
+  });
+});

package/Tests/Server/Utils/Telemetry/TelemetryContext.test.ts

@@ -0,0 +1,279 @@
+import { beforeEach, describe, expect, jest, test } from "@jest/globals";
+
+/*
+ * TelemetryContext is the AsyncLocalStorage-backed attribute bag that carries
+ * tenant identifiers (projectId, userId, ...) from where middleware learns
+ * them down to the spans and logs created much deeper in the call stack. These
+ * tests pin the contracts every one of its ~1958 span/log consumers leans on:
+ * scoping and inheritance, safe no-ops outside a scope, the merge rules, the
+ * best-effort payload extraction, and the DisableTelemetry short-circuit.
+ */
+
+type TelemetryContextClass =
+  typeof import("../../../../Server/Utils/Telemetry/TelemetryContext").default;
+
+/*
+ * Load a fresh module with the DisableTelemetry env gate forced to a known
+ * value. resetModules also gives each test its own AsyncLocalStorage so scopes
+ * never leak between tests.
+ */
+async function load(disabled: boolean): Promise<TelemetryContextClass> {
+  jest.resetModules();
+  jest.doMock("../../../../Server/EnvironmentConfig", () => {
+    return {
+      __esModule: true,
+      DisableTelemetry: disabled,
+    };
+  });
+
+  return (
+    (await import(
+      "../../../../Server/Utils/Telemetry/TelemetryContext"
+    )) as unknown as { default: TelemetryContextClass }
+  ).default;
+}
+
+describe("TelemetryContext (telemetry enabled)", () => {
+  beforeEach(() => {
+    jest.resetModules();
+  });
+
+  describe("getAttributes / runWithContext", () => {
+    test("returns an empty object when there is no active scope", async () => {
+      const TelemetryContext: TelemetryContextClass = await load(false);
+      expect(TelemetryContext.getAttributes()).toEqual({});
+    });
+
+    test("seeds the scope with the supplied attributes", async () => {
+      const TelemetryContext: TelemetryContextClass = await load(false);
+
+      const inside: Record<string, string | number | boolean> =
+        TelemetryContext.runWithContext(
+          { projectId: "p1", userId: "u1" },
+          () => {
+            return TelemetryContext.getAttributes();
+          },
+        );
+
+      expect(inside).toEqual({ projectId: "p1", userId: "u1" });
+    });
+
+    test("the scope does not leak past runWithContext", async () => {
+      const TelemetryContext: TelemetryContextClass = await load(false);
+
+      TelemetryContext.runWithContext({ projectId: "p1" }, () => {
+        return undefined;
+      });
+
+      expect(TelemetryContext.getAttributes()).toEqual({});
+    });
+
+    test("returns the callback's return value", async () => {
+      const TelemetryContext: TelemetryContextClass = await load(false);
+
+      const result: number = TelemetryContext.runWithContext(
+        { projectId: "p1" },
+        () => {
+          return 42;
+        },
+      );
+
+      expect(result).toBe(42);
+    });
+
+    test("drops undefined and null attribute values while seeding", async () => {
+      const TelemetryContext: TelemetryContextClass = await load(false);
+
+      const inside: Record<string, string | number | boolean> =
+        TelemetryContext.runWithContext(
+          {
+            projectId: "p1",
+            userId: undefined,
+            monitorId: null as unknown as undefined,
+          },
+          () => {
+            return TelemetryContext.getAttributes();
+          },
+        );
+
+      expect(inside).toEqual({ projectId: "p1" });
+    });
+  });
+
+  describe("nested scopes", () => {
+    test("a nested scope inherits the enclosing attributes", async () => {
+      const TelemetryContext: TelemetryContextClass = await load(false);
+
+      const inner: Record<string, string | number | boolean> =
+        TelemetryContext.runWithContext({ projectId: "p1" }, () => {
+          return TelemetryContext.runWithContext({ userId: "u1" }, () => {
+            return TelemetryContext.getAttributes();
+          });
+        });
+
+      expect(inner).toEqual({ projectId: "p1", userId: "u1" });
+    });
+
+    test("a nested scope can override an inherited attribute", async () => {
+      const TelemetryContext: TelemetryContextClass = await load(false);
+
+      const inner: Record<string, string | number | boolean> =
+        TelemetryContext.runWithContext({ projectId: "p1" }, () => {
+          return TelemetryContext.runWithContext({ projectId: "p2" }, () => {
+            return TelemetryContext.getAttributes();
+          });
+        });
+
+      expect(inner).toEqual({ projectId: "p2" });
+    });
+
+    test("leaving a nested scope restores the enclosing attributes", async () => {
+      const TelemetryContext: TelemetryContextClass = await load(false);
+
+      const outerAfter: Record<string, string | number | boolean> =
+        TelemetryContext.runWithContext({ projectId: "p1" }, () => {
+          TelemetryContext.runWithContext(
+            { projectId: "p2", userId: "u1" },
+            () => {
+              return undefined;
+            },
+          );
+          return TelemetryContext.getAttributes();
+        });
+
+      expect(outerAfter).toEqual({ projectId: "p1" });
+    });
+  });
+
+  describe("setAttributes", () => {
+    test("enriches the current scope", async () => {
+      const TelemetryContext: TelemetryContextClass = await load(false);
+
+      const inside: Record<string, string | number | boolean> =
+        TelemetryContext.runWithContext({ projectId: "p1" }, () => {
+          TelemetryContext.setAttributes({ userId: "u1", incidentId: "i1" });
+          return TelemetryContext.getAttributes();
+        });
+
+      expect(inside).toEqual({
+        projectId: "p1",
+        userId: "u1",
+        incidentId: "i1",
+      });
+    });
+
+    test("is a safe no-op outside any scope", async () => {
+      const TelemetryContext: TelemetryContextClass = await load(false);
+
+      expect(() => {
+        TelemetryContext.setAttributes({ userId: "u1" });
+      }).not.toThrow();
+      expect(TelemetryContext.getAttributes()).toEqual({});
+    });
+  });
+
+  describe("pickKnownAttributes", () => {
+    test("extracts only known identifier keys", async () => {
+      const TelemetryContext: TelemetryContextClass = await load(false);
+
+      expect(
+        TelemetryContext.pickKnownAttributes({
+          projectId: "p1",
+          monitorId: "m1",
+          somethingUnknown: "ignored",
+        }),
+      ).toEqual({ projectId: "p1", monitorId: "m1" });
+    });
+
+    test("keeps number and boolean values without stringifying them", async () => {
+      const TelemetryContext: TelemetryContextClass = await load(false);
+
+      expect(
+        TelemetryContext.pickKnownAttributes({
+          projectId: 5,
+          workspaceType: true,
+        }),
+      ).toEqual({ projectId: 5, workspaceType: true });
+    });
+
+    test("skips undefined and null identifier values", async () => {
+      const TelemetryContext: TelemetryContextClass = await load(false);
+
+      expect(
+        TelemetryContext.pickKnownAttributes({
+          projectId: "p1",
+          userId: undefined,
+          monitorId: null,
+        }),
+      ).toEqual({ projectId: "p1" });
+    });
+
+    test("stringifies an ObjectID-like value via toString()", async () => {
+      const TelemetryContext: TelemetryContextClass = await load(false);
+
+      expect(
+        TelemetryContext.pickKnownAttributes({
+          projectId: {
+            toString: () => {
+              return "obj-123";
+            },
+          },
+        }),
+      ).toEqual({ projectId: "obj-123" });
+    });
+
+    test("skips a plain object whose toString is '[object Object]'", async () => {
+      const TelemetryContext: TelemetryContextClass = await load(false);
+
+      expect(TelemetryContext.pickKnownAttributes({ projectId: {} })).toEqual(
+        {},
+      );
+    });
+
+    test("returns an empty object for non-object input", async () => {
+      const TelemetryContext: TelemetryContextClass = await load(false);
+
+      expect(TelemetryContext.pickKnownAttributes(null)).toEqual({});
+      expect(TelemetryContext.pickKnownAttributes(undefined)).toEqual({});
+      expect(TelemetryContext.pickKnownAttributes("string")).toEqual({});
+      expect(TelemetryContext.pickKnownAttributes(7)).toEqual({});
+    });
+  });
+});
+
+describe("TelemetryContext (telemetry disabled)", () => {
+  beforeEach(() => {
+    jest.resetModules();
+  });
+
+  test("runWithContext still runs the callback but seeds no scope", async () => {
+    const TelemetryContext: TelemetryContextClass = await load(true);
+
+    const inside: Record<string, string | number | boolean> =
+      TelemetryContext.runWithContext({ projectId: "p1" }, () => {
+        return TelemetryContext.getAttributes();
+      });
+
+    // No scope was created, so nothing is captured.
+    expect(inside).toEqual({});
+  });
+
+  test("runWithContext returns the callback value when disabled", async () => {
+    const TelemetryContext: TelemetryContextClass = await load(true);
+
+    expect(
+      TelemetryContext.runWithContext({ projectId: "p1" }, () => {
+        return "ok";
+      }),
+    ).toBe("ok");
+  });
+
+  test("setAttributes is a no-op when disabled", async () => {
+    const TelemetryContext: TelemetryContextClass = await load(true);
+
+    expect(() => {
+      TelemetryContext.setAttributes({ userId: "u1" });
+    }).not.toThrow();
+    expect(TelemetryContext.getAttributes()).toEqual({});
+  });
+});