@oneuptime/common 12.0.11 → 12.0.13

package/Tests/Server/Services/DatabaseServiceUpdateDebugLogging.test.ts

@@ -0,0 +1,282 @@
+/*
+ * PasswordHash carries a pre-existing TS5.9 diagnostic that fails any suite
+ * whose runtime require graph reaches it (DatabaseService, the base class of
+ * every concrete service, imports it). Nothing password-related is under
+ * test here, so the module is replaced WITH A FACTORY — an automock would
+ * still require (and type-check) the real file.
+ */
+jest.mock("../../../Server/Utils/PasswordHash", () => {
+  return {
+    __esModule: true,
+    default: {
+      hash: jest.fn(),
+      verify: jest.fn(),
+      generateSalt: jest.fn(),
+      needsUpgrade: jest.fn(),
+      applyPepper: jest.fn(),
+    },
+  };
+});
+
+import NetworkDeviceDiscoveryScanService from "../../../Server/Services/NetworkDeviceDiscoveryScanService";
+import ModelPermission from "../../../Server/Types/Database/Permissions/Index";
+import ConfigLogLevel from "../../../Server/Types/ConfigLogLevel";
+import UpdateBy from "../../../Server/Types/Database/UpdateBy";
+import logger from "../../../Server/Utils/Logger";
+import NetworkDeviceDiscoveryScan from "../../../Models/DatabaseModels/NetworkDeviceDiscoveryScan";
+import ObjectID from "../../../Types/ObjectID";
+import { JSONObject } from "../../../Types/JSON";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
+
+/*
+ * Regression tests for the log-level gate on _updateBy's per-row debug
+ * logging.
+ *
+ * _updateBy used to build a pretty-printed JSON.stringify(updatedItem,
+ * null, 2) for EVERY matched row of EVERY update, unconditionally — and
+ * logger.debug then discarded it at the default INFO level. That was pure
+ * per-row CPU and allocation fleet-wide, and it also meant a payload whose
+ * serialization throws (e.g. a circular structure) failed the whole update
+ * even though nothing would ever be logged.
+ *
+ * The fix hoists a single logger.getLogLevel() check above the per-item loop
+ * and only enters the debug-logging block (stringify + LogAttributes
+ * allocation) when the level is DEBUG. These tests pin:
+ *
+ *   - at INFO: the block is skipped entirely (no debug calls, no stringify,
+ *     one level read for the whole update rather than per row), and the
+ *     write itself is untouched;
+ *   - at DEBUG: logger.debug receives the byte-identical pretty-printed
+ *     payload it always did;
+ *   - the one blessed semantic delta: a payload whose serialization throws
+ *     now only throws at DEBUG level.
+ */
+
+type ScanUpdateData = UpdateBy<NetworkDeviceDiscoveryScan>["data"];
+
+describe("DatabaseService._updateBy — per-row debug logging is gated on the log level", () => {
+  let saveMock: MockFunction;
+  let updateMock: MockFunction;
+  let debugSpy: MockFunction;
+  let getLogLevelSpy: MockFunction;
+
+  const mockFoundItems: (ids: Array<ObjectID>) => void = (
+    ids: Array<ObjectID>,
+  ): void => {
+    const items: Array<NetworkDeviceDiscoveryScan> = ids.map((id: ObjectID) => {
+      const item: NetworkDeviceDiscoveryScan = new NetworkDeviceDiscoveryScan();
+      item._id = id.toString();
+      return item;
+    });
+
+    jest
+      .spyOn(NetworkDeviceDiscoveryScanService as any, "_findBy")
+      .mockResolvedValue(items as never);
+  };
+
+  const setLogLevel: (level: ConfigLogLevel) => void = (
+    level: ConfigLogLevel,
+  ): void => {
+    getLogLevelSpy = jest
+      .spyOn(logger, "getLogLevel")
+      .mockReturnValue(level) as unknown as MockFunction;
+  };
+
+  beforeEach(() => {
+    jest.restoreAllMocks();
+    jest.clearAllMocks();
+
+    debugSpy = jest.spyOn(logger, "debug").mockImplementation(() => {
+      return undefined;
+    }) as unknown as MockFunction;
+
+    saveMock = getJestMockFunction();
+    saveMock.mockImplementation((item: unknown) => {
+      return Promise.resolve(item);
+    });
+    updateMock = getJestMockFunction();
+    updateMock.mockImplementation(() => {
+      return Promise.resolve({ affected: 1 });
+    });
+    jest
+      .spyOn(NetworkDeviceDiscoveryScanService, "getRepository")
+      .mockReturnValue({ save: saveMock, update: updateMock } as never);
+
+    // The permission layer needs a DB and is not what these tests exercise.
+    jest
+      .spyOn(ModelPermission, "checkUpdatePermissionByModel")
+      .mockResolvedValue(undefined as never);
+    jest
+      .spyOn(ModelPermission, "checkUpdateQueryPermissions")
+      .mockImplementation(((
+        _modelType: unknown,
+        query: unknown,
+      ): Promise<unknown> => {
+        return Promise.resolve(query);
+      }) as never);
+  });
+
+  afterEach(() => {
+    /*
+     * Restores logger.getLogLevel / logger.debug so other suites see the
+     * real log level again.
+     */
+    jest.restoreAllMocks();
+  });
+
+  test("at INFO, an update whose payload JSON.stringify would throw on still completes", async () => {
+    setLogLevel(ConfigLogLevel.INFO);
+
+    const scanId: ObjectID = ObjectID.generate();
+    mockFoundItems([scanId]);
+
+    const circular: JSONObject = { name: "loop" };
+    circular["self"] = circular;
+    expect(() => {
+      return JSON.stringify(circular);
+    }).toThrow();
+
+    const updatedCount: number =
+      await NetworkDeviceDiscoveryScanService.updateOneById({
+        id: scanId,
+        data: { status: circular } as unknown as ScanUpdateData,
+        props: { isRoot: true },
+      });
+
+    expect(updatedCount).toBe(1);
+    expect(updateMock).toHaveBeenCalledTimes(1);
+    expect(saveMock).not.toHaveBeenCalled();
+
+    /*
+     * The write payload is untouched: the very same object reference lands
+     * in the SET, never a serialized copy.
+     */
+    const whereClause: JSONObject = updateMock.mock.calls[0]![0] as JSONObject;
+    const setPayload: JSONObject = updateMock.mock.calls[0]![1] as JSONObject;
+    expect(whereClause["_id"]).toBe(scanId.toString());
+    expect(setPayload["status"]).toBe(circular);
+  });
+
+  test("at INFO, logger.debug is never called for any matched row", async () => {
+    setLogLevel(ConfigLogLevel.INFO);
+
+    const scanIds: Array<ObjectID> = [
+      ObjectID.generate(),
+      ObjectID.generate(),
+      ObjectID.generate(),
+    ];
+    mockFoundItems(scanIds);
+
+    const updatedCount: number =
+      await NetworkDeviceDiscoveryScanService.updateBy({
+        query: {},
+        data: { status: "In Progress" } as ScanUpdateData,
+        limit: scanIds.length,
+        skip: 0,
+        props: { isRoot: true },
+      });
+
+    // On the old code this was two debug calls per row (six here).
+    expect(debugSpy).not.toHaveBeenCalled();
+
+    // The write itself is unchanged.
+    expect(updatedCount).toBe(scanIds.length);
+    expect(updateMock).toHaveBeenCalledTimes(scanIds.length);
+    for (let i: number = 0; i < scanIds.length; i++) {
+      const whereClause: JSONObject = updateMock.mock.calls[
+        i
+      ]![0] as JSONObject;
+      const setPayload: JSONObject = updateMock.mock.calls[i]![1] as JSONObject;
+      expect(whereClause["_id"]).toBe(scanIds[i]!.toString());
+      expect(setPayload["status"]).toBe("In Progress");
+    }
+  });
+
+  test("the level check is hoisted: one getLogLevel read for the whole update, not one per row", async () => {
+    setLogLevel(ConfigLogLevel.INFO);
+
+    mockFoundItems([
+      ObjectID.generate(),
+      ObjectID.generate(),
+      ObjectID.generate(),
+    ]);
+
+    await NetworkDeviceDiscoveryScanService.updateBy({
+      query: {},
+      data: { status: "In Progress" } as ScanUpdateData,
+      limit: 3,
+      skip: 0,
+      props: { isRoot: true },
+    });
+
+    expect(getLogLevelSpy).toHaveBeenCalledTimes(1);
+  });
+
+  test("at DEBUG, logger.debug receives the exact pretty-printed payload per row, as before", async () => {
+    setLogLevel(ConfigLogLevel.DEBUG);
+
+    const projectId: ObjectID = ObjectID.generate();
+    const scanIds: Array<ObjectID> = [ObjectID.generate(), ObjectID.generate()];
+    mockFoundItems(scanIds);
+
+    await NetworkDeviceDiscoveryScanService.updateBy({
+      query: {},
+      data: { status: "In Progress" } as ScanUpdateData,
+      limit: scanIds.length,
+      skip: 0,
+      props: { isRoot: true, tenantId: projectId },
+    });
+
+    /*
+     * Two debug calls per matched row: the "Updated Item" marker, then the
+     * pretty-printed payload.
+     */
+    expect(debugSpy).toHaveBeenCalledTimes(scanIds.length * 2);
+
+    for (let i: number = 0; i < scanIds.length; i++) {
+      const expectedPayload: string = JSON.stringify(
+        { status: "In Progress", _id: scanIds[i]!.toString() },
+        null,
+        2,
+      );
+      /*
+       * Guard the guard: the expectation itself must be the multi-line
+       * pretty-printed form, not a compact one.
+       */
+      expect(expectedPayload).toContain("\n");
+
+      expect(debugSpy.mock.calls[i * 2]![0]).toBe("Updated Item");
+      expect(debugSpy.mock.calls[i * 2]![1]).toEqual({
+        projectId: projectId.toString(),
+      });
+      expect(debugSpy.mock.calls[i * 2 + 1]![0]).toBe(expectedPayload);
+      expect(debugSpy.mock.calls[i * 2 + 1]![1]).toEqual({
+        projectId: projectId.toString(),
+      });
+    }
+
+    expect(updateMock).toHaveBeenCalledTimes(scanIds.length);
+  });
+
+  test("at DEBUG, a payload whose serialization throws still fails the update (blessed delta)", async () => {
+    setLogLevel(ConfigLogLevel.DEBUG);
+
+    const scanId: ObjectID = ObjectID.generate();
+    mockFoundItems([scanId]);
+
+    const circular: JSONObject = { name: "loop" };
+    circular["self"] = circular;
+
+    await expect(
+      NetworkDeviceDiscoveryScanService.updateOneById({
+        id: scanId,
+        data: { status: circular } as unknown as ScanUpdateData,
+        props: { isRoot: true },
+      }),
+    ).rejects.toThrow();
+
+    expect(updateMock).not.toHaveBeenCalled();
+    expect(saveMock).not.toHaveBeenCalled();
+  });
+});

package/Tests/Server/Services/NetworkSiteService.test.ts

@@ -201,14 +201,17 @@ describe("NetworkSiteService.recomputeRollupForSite", () => {
     expect(spies.timelineCreate).not.toHaveBeenCalled();
   });
 
-  it("uses the freshness fallback for devices without a stamped status", async () => {
+  it("uses the SNMP fallback for devices without a stamped status", async () => {
     const spies: RollupSpies = setupRollup({
       site: fakeSite({ currentMonitorStatusId: OPERATIONAL_STATUS_ID }),
       devices: [
         {
           id: DEVICE_ID,
-          // Unmonitored and last seen an hour ago -> offline equivalent.
+          // Unmonitored, and its last poll could not reach it.
+          isReachable: false,
+          lastPolledAt: new Date(Date.now() - 60 * 1000),
           lastSeenAt: new Date(Date.now() - 60 * 60 * 1000),
+          pollingIntervalInMinutes: 5,
         },
       ] as unknown as Array<NetworkDevice>,
     });
@@ -221,6 +224,57 @@ describe("NetworkSiteService.recomputeRollupForSite", () => {
     );
   });
 
+  /*
+   * Issue #3220 at the site card. A probe behind on a large fleet leaves
+   * every device's last successful poll well outside the old fixed
+   * 15-minute freshness window, and the site above them went red even
+   * though each one had answered. The rollup asks about the last poll's
+   * OUTCOME now, so it does not.
+   */
+  it("issue #3220: devices answering 21 minutes ago keep the site operational", async () => {
+    const spies: RollupSpies = setupRollup({
+      site: fakeSite({ currentMonitorStatusId: OFFLINE_STATUS_ID }),
+      devices: [
+        {
+          id: DEVICE_ID,
+          isReachable: true,
+          lastPolledAt: new Date(Date.now() - 21 * 60 * 1000),
+          lastSeenAt: new Date(Date.now() - 21 * 60 * 1000),
+          pollingIntervalInMinutes: 5,
+        },
+      ] as unknown as Array<NetworkDevice>,
+    });
+
+    await NetworkSiteService.recomputeRollupForSite(SITE_ID);
+
+    const updateArgs: any = spies.updateColumns.mock.calls[0]![0];
+    expect(updateArgs.data.currentMonitorStatusId.toString()).toBe(
+      OPERATIONAL_STATUS_ID.toString(),
+    );
+  });
+
+  /*
+   * The rollup reads four columns and the query has to fetch all four. A
+   * missing `isReachable` here compiles, runs, and silently drops the whole
+   * subtree back onto the legacy freshness path.
+   */
+  it("selects every column the reachability rule reads", async () => {
+    const spies: RollupSpies = setupRollup({
+      site: fakeSite({ currentMonitorStatusId: OPERATIONAL_STATUS_ID }),
+      devices: [],
+    });
+
+    await NetworkSiteService.recomputeRollupForSite(SITE_ID);
+
+    const select: Record<string, unknown> =
+      spies.deviceFindBy.mock.calls[0]![0].select;
+
+    expect(select["isReachable"]).toBe(true);
+    expect(select["lastPolledAt"]).toBe(true);
+    expect(select["lastSeenAt"]).toBe(true);
+    expect(select["pollingIntervalInMinutes"]).toBe(true);
+  });
+
   it("does nothing when the site does not exist", async () => {
     const spies: RollupSpies = setupRollup({ site: null, devices: [] });
 

package/Tests/Server/Services/TelemetryResourceFacetFilters.test.ts

@@ -0,0 +1,267 @@
+/*
+ * The identifier lookup is stubbed: these tests are about what the SQL and
+ * the rewritten query look like, and leaving it live would make them depend
+ * on a reachable Postgres.
+ */
+const kubernetesClusterFindBy: jest.Mock = jest.fn();
+
+jest.mock("../../../Server/Services/KubernetesClusterService", () => {
+  return { __esModule: true, default: { findBy: kubernetesClusterFindBy } };
+});
+
+import LogAggregationService from "../../../Server/Services/LogAggregationService";
+import TraceAggregationService from "../../../Server/Services/TraceAggregationService";
+import LogService from "../../../Server/Services/LogService";
+import SpanService from "../../../Server/Services/SpanService";
+import { Results } from "../../../Server/Services/AnalyticsDatabaseService";
+import { Statement } from "../../../Server/Utils/AnalyticsDatabase/Statement";
+import { ResourceEntityScope } from "../../../Server/Utils/Telemetry/ResourceEntityFilter";
+import { JSONObject } from "../../../Types/JSON";
+import ObjectID from "../../../Types/ObjectID";
+import { keyForKubernetesCluster } from "../../../Utils/Telemetry/EntityKey";
+import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
+
+/*
+ * End of the read path for issue #3216. Selecting a Kubernetes cluster used to
+ * compile to `primaryEntityId = '<clusterId>'`, and OTLP telemetry that
+ * carries a `service.name` is primary-keyed on its SERVICE — the cluster only
+ * appears in `entityKeys`. So the predicate matched zero rows, and pairing the
+ * cluster with a service made results reappear because both ids shared one
+ * `IN (...)` list.
+ *
+ * These tests pin the two surfaces that have to agree on what a resource facet
+ * selects: the aggregation statements behind the histogram / facets / analytics
+ * panels, and the list query the rows themselves come from. A chart that
+ * disagrees with its list is its own bug.
+ */
+
+const projectId: ObjectID = ObjectID.generate();
+const startTime: Date = new Date("2026-08-14T11:00:00.000Z");
+const endTime: Date = new Date("2026-08-14T12:00:00.000Z");
+
+const clusterId: string = ObjectID.generate().toString();
+const serviceId: string = ObjectID.generate().toString();
+const clusterEntityKey: string = keyForKubernetesCluster(
+  projectId.toString(),
+  "prod-eu",
+);
+
+const clusterScope: ResourceEntityScope = {
+  entityIds: [clusterId],
+  entityKeys: [clusterEntityKey],
+  attributeKey: "resource.k8s.cluster.name",
+  attributeValues: ["prod-eu"],
+};
+
+/*
+ * Capture the statements a service builds instead of running them. The
+ * assertions are about the SQL shape (which branches, how they are combined),
+ * which is what decides whether a row matches.
+ */
+function captureStatements(
+  service: { executeQuery: (statement: Statement) => Promise<Results> },
+  rows: Array<JSONObject> = [],
+): Array<Statement> {
+  const captured: Array<Statement> = [];
+
+  jest.spyOn(service as never, "executeQuery").mockImplementation(((
+    statement: Statement,
+  ): Promise<Results> => {
+    captured.push(statement);
+
+    return Promise.resolve({
+      json: (): Promise<unknown> => {
+        return Promise.resolve({ data: rows });
+      },
+    } as unknown as Results);
+  }) as never);
+
+  return captured;
+}
+
+describe("resource facet filters reach the telemetry read path", () => {
+  beforeEach(() => {
+    kubernetesClusterFindBy.mockReset();
+    kubernetesClusterFindBy.mockResolvedValue([
+      { clusterIdentifier: "prod-eu" },
+    ]);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe("LogAggregationService", () => {
+    test("the histogram matches a cluster by entity key, not only by primaryEntityId", async () => {
+      const captured: Array<Statement> = captureStatements(LogService);
+
+      await LogAggregationService.getHistogram({
+        projectId,
+        startTime,
+        endTime,
+        bucketSizeInMinutes: 5,
+        resourceScopes: [clusterScope],
+      });
+
+      const query: string = captured[0]!.query;
+
+      expect(query).toContain("primaryEntityId IN");
+      expect(query).toContain("hasAny(entityKeys,");
+      expect(query).toContain("attributes[");
+      expect(Object.values(captured[0]!.query_params)).toContainEqual([
+        clusterEntityKey,
+      ]);
+    });
+
+    test("a cluster and a service are separate predicates, so they intersect", async () => {
+      const captured: Array<Statement> = captureStatements(LogService);
+
+      await LogAggregationService.getHistogram({
+        projectId,
+        startTime,
+        endTime,
+        bucketSizeInMinutes: 5,
+        serviceIds: [new ObjectID(serviceId)],
+        resourceScopes: [clusterScope],
+      });
+
+      const query: string = captured[0]!.query;
+
+      /*
+       * Two AND-ed predicates. Before the fix both ids went into ONE
+       * `primaryEntityId IN (...)`, which OR-ed them — that is why adding a
+       * service "fixed" the empty result while dropping the cluster.
+       */
+      expect(query).toContain("AND primaryEntityId IN");
+      expect(query).toContain("AND (primaryEntityId IN");
+      expect(query).toContain("hasAny(entityKeys,");
+    });
+
+    test("facet value queries carry the same scope as the histogram", async () => {
+      const captured: Array<Statement> = captureStatements(LogService);
+
+      await LogAggregationService.getFacetValues({
+        projectId,
+        startTime,
+        endTime,
+        facetKey: "severityText",
+        resourceScopes: [clusterScope],
+      });
+
+      expect(captured[0]!.query).toContain("hasAny(entityKeys,");
+    });
+
+    test("no resource scope leaves the statement exactly as it was", async () => {
+      const captured: Array<Statement> = captureStatements(LogService);
+
+      await LogAggregationService.getHistogram({
+        projectId,
+        startTime,
+        endTime,
+        bucketSizeInMinutes: 5,
+      });
+
+      expect(captured[0]!.query).not.toContain("hasAny(entityKeys,");
+      expect(captured[0]!.query).not.toContain("AND (primaryEntityId IN");
+    });
+  });
+
+  describe("TraceAggregationService", () => {
+    test("the span histogram matches a cluster by entity key too", async () => {
+      const captured: Array<Statement> = captureStatements(SpanService);
+
+      await TraceAggregationService.getHistogram({
+        projectId,
+        startTime,
+        endTime,
+        bucketSizeInMinutes: 5,
+        resourceScopes: [clusterScope],
+      });
+
+      const query: string = captured[0]!.query;
+
+      expect(query).toContain("primaryEntityId IN");
+      expect(query).toContain("hasAny(entityKeys,");
+    });
+
+    test("no resource scope leaves the span statement unchanged", async () => {
+      const captured: Array<Statement> = captureStatements(SpanService);
+
+      await TraceAggregationService.getHistogram({
+        projectId,
+        startTime,
+        endTime,
+        bucketSizeInMinutes: 5,
+      });
+
+      expect(captured[0]!.query).not.toContain("hasAny(entityKeys,");
+    });
+  });
+
+  describe("list queries", () => {
+    /*
+     * The list runs through the generic analytics endpoint, so the ids the
+     * explorer sends have to be resolved in the service's own onBeforeFind
+     * hook — that is the last point where Postgres is still reachable.
+     */
+    type FindByShape = {
+      query: Record<string, unknown>;
+      props: { tenantId: ObjectID };
+    };
+
+    test("LogService resolves the explorer's resource ids before compiling", async () => {
+      const findBy: FindByShape = {
+        query: { resourceFilters: { kubernetesClusterId: [clusterId] } },
+        props: { tenantId: projectId },
+      };
+
+      await (
+        LogService as unknown as {
+          onBeforeFind: (input: FindByShape) => Promise<unknown>;
+        }
+      ).onBeforeFind(findBy);
+
+      expect(findBy.query["resourceFilters"]).toBeUndefined();
+      expect(findBy.query["resourceEntityScopes"]).toBeDefined();
+
+      const scopes: Array<ResourceEntityScope> = findBy.query[
+        "resourceEntityScopes"
+      ] as Array<ResourceEntityScope>;
+
+      expect(scopes[0]!.entityIds).toEqual([clusterId]);
+      // Resolved through Postgres to the key ingest stamped on the rows.
+      expect(scopes[0]!.entityKeys).toEqual([clusterEntityKey]);
+    });
+
+    test("SpanService resolves them the same way", async () => {
+      const findBy: FindByShape = {
+        query: { resourceFilters: { kubernetesClusterId: [clusterId] } },
+        props: { tenantId: projectId },
+      };
+
+      await (
+        SpanService as unknown as {
+          onBeforeFind: (input: FindByShape) => Promise<unknown>;
+        }
+      ).onBeforeFind(findBy);
+
+      expect(findBy.query["resourceFilters"]).toBeUndefined();
+      expect(findBy.query["resourceEntityScopes"]).toBeDefined();
+    });
+
+    test("a query without resource filters is handed through untouched", async () => {
+      const findBy: FindByShape = {
+        query: { severityText: "Error" },
+        props: { tenantId: projectId },
+      };
+
+      await (
+        LogService as unknown as {
+          onBeforeFind: (input: FindByShape) => Promise<unknown>;
+        }
+      ).onBeforeFind(findBy);
+
+      expect(findBy.query).toEqual({ severityText: "Error" });
+    });
+  });
+});