@oneuptime/common 14.0.2 → 14.0.5

package/Tests/Server/Utils/Monitor/SeriesResourceLinker.test.ts

@@ -22,6 +22,7 @@ import Alert from "../../../../Models/DatabaseModels/Alert";
 import Host from "../../../../Models/DatabaseModels/Host";
 import Incident from "../../../../Models/DatabaseModels/Incident";
 import CephClusterService from "../../../../Server/Services/CephClusterService";
+import DatabaseServerService from "../../../../Server/Services/DatabaseServerService";
 import DockerHostService from "../../../../Server/Services/DockerHostService";
 import DockerSwarmClusterService from "../../../../Server/Services/DockerSwarmClusterService";
 import HostService from "../../../../Server/Services/HostService";
@@ -115,6 +116,15 @@ const RESOURCE_SERVICES: Array<ResourceServiceUnderTest> = [
     nameColumn: "name",
   },
   { relation: "iotFleets", service: IoTFleetService, nameColumn: "name" },
+  /*
+   * Databases resolve by the `oneuptime.database.server.id` stamp only,
+   * so `nameColumn` is never queried for them (see the database tests).
+   */
+  {
+    relation: "databaseServers",
+    service: DatabaseServerService,
+    nameColumn: "name",
+  },
 ];
 
 /*
@@ -195,6 +205,7 @@ function emptyResourceContext(): SeriesResolvedResourceIds {
     cephClusterIds: [],
     dockerSwarmClusterIds: [],
     iotFleetIds: [],
+    databaseServerIds: [],
   };
 }
 
@@ -535,6 +546,7 @@ describe("SeriesResourceLinker.linkSeriesResourcesToModel", () => {
         "ceph.cluster.name": "ceph-1",
         "docker.swarm.cluster.name": "swarm-1",
         "iot.fleet.name": "fleet-1",
+        "oneuptime.database.server.id": "d0000000-0000-4000-8000-000000000001",
       },
       projectId: PROJECT_ID,
     });
@@ -551,8 +563,8 @@ describe("SeriesResourceLinker.linkSeriesResourcesToModel", () => {
       }
     }
 
-    // 10 types, and hosts get an extra query for the id stamp.
-    expect(assertedQueries).toBe(11);
+    // 11 types, and hosts get an extra query for the id stamp.
+    expect(assertedQueries).toBe(12);
   });
 
   test("does not link a resource that belongs to another project", async () => {
@@ -677,6 +689,227 @@ describe("SeriesResourceLinker.resolveResourcesFromSeriesLabels", () => {
     expect(resolved.vmwareVCenterIds).toEqual([]);
     expect(resolved.cephClusterIds).toEqual([]);
     expect(resolved.dockerSwarmClusterIds).toEqual([]);
+    expect(resolved.databaseServerIds).toEqual([]);
+  });
+
+  test("returns the database a series names by its id stamp", async () => {
+    rowsByRelation.set("databaseServers", [
+      { _id: "d0000000-0000-4000-8000-000000000001" },
+    ]);
+
+    const resolved: SeriesResolvedResourceIds =
+      await SeriesResourceLinker.resolveResourcesFromSeriesLabels({
+        seriesLabels: {
+          "oneuptime.database.server.id":
+            "d0000000-0000-4000-8000-000000000001",
+        },
+        projectId: PROJECT_ID,
+      });
+
+    expect(resolved).toEqual({
+      ...emptyResourceContext(),
+      databaseServerIds: ["d0000000-0000-4000-8000-000000000001"],
+    });
+  });
+});
+
+describe("SeriesResourceLinker — databases", () => {
+  test.each([
+    ["oneuptime.database.server.id"],
+    ["resource.oneuptime.database.server.id"],
+  ])(
+    "links the database a series identifies by the %s stamp",
+    async (key: string) => {
+      rowsByRelation.set("databaseServers", [
+        { _id: "d0000000-0000-4000-8000-000000000001" },
+      ]);
+
+      const alert: Alert = new Alert();
+
+      await SeriesResourceLinker.linkSeriesResourcesToModel({
+        model: alert,
+        seriesLabels: { [key]: "d0000000-0000-4000-8000-000000000001" },
+        projectId: PROJECT_ID,
+      });
+
+      expect(idsOn(alert, "databaseServers")).toEqual([
+        "d0000000-0000-4000-8000-000000000001",
+      ]);
+      expect(callCount("databaseServers")).toBe(1);
+
+      const query: JSONObject = relationQueries("databaseServers")[0]!;
+      expect(query["projectId"]).toBe(PROJECT_ID);
+      expect(includesValues(query["_id"])).toEqual([
+        "d0000000-0000-4000-8000-000000000001",
+      ]);
+      // Id stamp only: the lookup must never widen to the name column.
+      expect(query["name"]).toBeUndefined();
+    },
+  );
+
+  test.each([
+    ["oneuptime.database.server.name"],
+    ["resource.oneuptime.database.server.name"],
+  ])(
+    "never resolves a database from the %s display-name stamp",
+    async (key: string) => {
+      /*
+       * The display name is neither unique ("PostgreSQL pg:5432" in two
+       * clusters) nor stable (users rename databases), so a name-only
+       * series links no database rather than every same-named one.
+       */
+      rowsByRelation.set("databaseServers", [
+        { _id: "d0000000-0000-4000-8000-000000000001" },
+      ]);
+
+      const alert: Alert = new Alert();
+
+      await SeriesResourceLinker.linkSeriesResourcesToModel({
+        model: alert,
+        seriesLabels: { [key]: "PostgreSQL db.prod:5432" },
+        projectId: PROJECT_ID,
+      });
+
+      expect(callCount("databaseServers")).toBe(0);
+      expect(alert.databaseServers).toBeUndefined();
+    },
+  );
+
+  test("a malformed database id stamp issues no lookup and links nothing", async () => {
+    /*
+     * A user-typed DATABASE_SERVER_ID that is not a UUID would make the
+     * uuid primary-key query throw out of alert / incident creation.
+     */
+    rowsByRelation.set("databaseServers", [
+      { _id: "d0000000-0000-4000-8000-000000000001" },
+    ]);
+
+    const alert: Alert = new Alert();
+
+    await SeriesResourceLinker.linkSeriesResourcesToModel({
+      model: alert,
+      seriesLabels: {
+        "resource.oneuptime.database.server.id": "prod-postgres",
+      },
+      projectId: PROJECT_ID,
+    });
+
+    expect(callCount("databaseServers")).toBe(0);
+    expect(alert.databaseServers).toBeUndefined();
+  });
+
+  test("looks up every database id of a multi-valued label in one query", async () => {
+    rowsByRelation.set("databaseServers", [
+      { _id: "d0000000-0000-4000-8000-000000000001" },
+      { _id: "d0000000-0000-4000-8000-000000000002" },
+    ]);
+
+    const incident: Incident = new Incident();
+
+    await SeriesResourceLinker.linkSeriesResourcesToModel({
+      model: incident,
+      seriesLabels: {
+        "oneuptime.database.server.id": [
+          "d0000000-0000-4000-8000-000000000001",
+          "d0000000-0000-4000-8000-000000000002",
+        ],
+      },
+      projectId: PROJECT_ID,
+    });
+
+    expect(callCount("databaseServers")).toBe(1);
+    expect(
+      includesValues(relationQueries("databaseServers")[0]!["_id"]).sort(),
+    ).toEqual([
+      "d0000000-0000-4000-8000-000000000001",
+      "d0000000-0000-4000-8000-000000000002",
+    ]);
+    expect(idsOn(incident, "databaseServers").sort()).toEqual([
+      "d0000000-0000-4000-8000-000000000001",
+      "d0000000-0000-4000-8000-000000000002",
+    ]);
+  });
+
+  test("does not link a database id stamp from another project", async () => {
+    /*
+     * The fake findBy answers [] — as the real, project-scoped query does
+     * for a stale or hostile id that belongs to another tenant.
+     */
+    const alert: Alert = new Alert();
+
+    await SeriesResourceLinker.linkSeriesResourcesToModel({
+      model: alert,
+      seriesLabels: {
+        "oneuptime.database.server.id": "f0000000-0000-4000-8000-000000000001",
+      },
+      projectId: OTHER_PROJECT_ID,
+    });
+
+    expect(relationQueries("databaseServers")[0]!["projectId"]).toBe(
+      OTHER_PROJECT_ID,
+    );
+    expect(alert.databaseServers).toBeUndefined();
+  });
+
+  test("links the database alongside the service of the same series", async () => {
+    /*
+     * A database receiver batch carries no service.name, but a monitor can
+     * group by both a service attribute and the database stamp; the two
+     * relations must both be filled and must not interfere.
+     */
+    rowsByRelation.set("databaseServers", [
+      { _id: "d0000000-0000-4000-8000-000000000001" },
+    ]);
+    rowsByRelation.set("services", [{ _id: "service-1" }]);
+
+    const alert: Alert = new Alert();
+
+    await SeriesResourceLinker.linkSeriesResourcesToModel({
+      model: alert,
+      seriesLabels: {
+        "oneuptime.database.server.id": "d0000000-0000-4000-8000-000000000001",
+        "service.name": "checkout",
+      },
+      projectId: PROJECT_ID,
+    });
+
+    expect(idsOn(alert, "databaseServers")).toEqual([
+      "d0000000-0000-4000-8000-000000000001",
+    ]);
+    expect(idsOn(alert, "services")).toEqual(["service-1"]);
+    expect(alert.hosts).toBeUndefined();
+  });
+
+  test("merges the step-config database with the label one, deduping", async () => {
+    rowsByRelation.set("databaseServers", [
+      { _id: "d0000000-0000-4000-8000-000000000001" },
+    ]);
+
+    const alert: Alert = new Alert();
+
+    await SeriesResourceLinker.linkSeriesResourcesToModel({
+      model: alert,
+      seriesLabels: {
+        "oneuptime.database.server.id": "d0000000-0000-4000-8000-000000000001",
+      },
+      projectId: PROJECT_ID,
+    });
+
+    SeriesResourceLinker.attachResolvedResources({
+      model: alert,
+      resolved: {
+        ...emptyResourceContext(),
+        databaseServerIds: [
+          "d0000000-0000-4000-8000-000000000001",
+          "d0000000-0000-4000-8000-000000000002",
+        ],
+      },
+    });
+
+    expect(idsOn(alert, "databaseServers")).toEqual([
+      "d0000000-0000-4000-8000-000000000001",
+      "d0000000-0000-4000-8000-000000000002",
+    ]);
   });
 });
 
@@ -799,6 +1032,7 @@ describe("SeriesResourceLinker.attachResolvedResources", () => {
     expect(alert.cephClusters).toBeUndefined();
     expect(alert.dockerSwarmClusters).toBeUndefined();
     expect(alert.iotFleets).toBeUndefined();
+    expect(alert.databaseServers).toBeUndefined();
   });
 
   test("attaches to an incident the same way", () => {

package/Tests/Server/Utils/SeriesResourceLabels.test.ts

@@ -1,4 +1,6 @@
 import SeriesResourceLabels, {
+  AllResourceIdentityLabelKeys,
+  DatabaseServerIdLabelKeys,
   HostNameLabelKeys,
   SeriesResourceRefs,
 } from "../../../Server/Utils/Monitor/SeriesResourceLabels";
@@ -170,3 +172,71 @@ describe("SeriesResourceLabels.extractResourceRefs", () => {
     expect(dockerRefs.dockerSwarmClusterNames).toEqual([]);
   });
 });
+
+describe("SeriesResourceLabels — databases", () => {
+  test("the database id keys are the stamp and its resource.-prefixed twin", () => {
+    expect([...DatabaseServerIdLabelKeys].sort()).toEqual([
+      "oneuptime.database.server.id",
+      "resource.oneuptime.database.server.id",
+    ]);
+  });
+
+  test("every database id key is a reserved resource identity key", () => {
+    /*
+     * AllResourceIdentityLabelKeys is what the custom-code metric guard
+     * refuses to let a script stamp; a script must not be able to claim
+     * a series belongs to a database.
+     */
+    for (const key of DatabaseServerIdLabelKeys) {
+      expect(AllResourceIdentityLabelKeys).toContain(key);
+    }
+    expect(AllResourceIdentityLabelKeys).not.toContain(
+      "oneuptime.database.server.name",
+    );
+  });
+
+  test("reads the database id in both spellings, deduped", () => {
+    const refs: SeriesResourceRefs = SeriesResourceLabels.extractResourceRefs({
+      "oneuptime.database.server.id": "d0000000-0000-4000-8000-000000000001",
+      "resource.oneuptime.database.server.id": [
+        "d0000000-0000-4000-8000-000000000001",
+        "d0000000-0000-4000-8000-000000000002",
+      ],
+    });
+
+    expect(refs.databaseServerIds.sort()).toEqual([
+      "d0000000-0000-4000-8000-000000000001",
+      "d0000000-0000-4000-8000-000000000002",
+    ]);
+  });
+
+  test("drops a database id that is not a UUID", () => {
+    /*
+     * The resource-prefixed value is the agent's DATABASE_SERVER_ID, typed
+     * by a user; a malformed one must not reach the uuid primary-key
+     * lookup, where it would throw out of alert / incident creation.
+     */
+    const refs: SeriesResourceRefs = SeriesResourceLabels.extractResourceRefs({
+      "resource.oneuptime.database.server.id": [
+        "prod-postgres",
+        "d0000000-0000-4000-8000-000000000001",
+        "",
+      ],
+    });
+
+    expect(refs.databaseServerIds).toEqual([
+      "d0000000-0000-4000-8000-000000000001",
+    ]);
+  });
+
+  test("a database label does not leak into any other resource type", () => {
+    const refs: SeriesResourceRefs = SeriesResourceLabels.extractResourceRefs({
+      "oneuptime.database.server.id": "d0000000-0000-4000-8000-000000000001",
+      "oneuptime.database.server.name": "PostgreSQL db.prod:5432",
+    });
+
+    const { databaseServerIds, ...others } = refs;
+    expect(databaseServerIds).toEqual(["d0000000-0000-4000-8000-000000000001"]);
+    expect(Object.values(others).flat()).toEqual([]);
+  });
+});

package/Tests/Server/Utils/SessionReplay/SessionReplayGateCachePolicy.test.ts

@@ -372,3 +372,106 @@ describe("SessionReplayGateCache.resolvePolicy names the refusal", (): void => {
     expect(resolution.refusal).toBeNull();
   });
 });
+
+/*
+ * RumApplication.sessionReplaySameOriginTracePropagation: the per-app switch
+ * for the recorder's automatic same-origin traceparent + tracestate. The
+ * column is NOT NULL DEFAULT true (on for existing applications too), so
+ * the gate reads anything but an explicit false as on - the model-default
+ * rule of the fallbacks above, not the feature-off rule of the origin list.
+ * Only an operator who switched it off gets it off.
+ */
+describe("SessionReplayGateCache same-origin trace propagation switch", (): void => {
+  beforeEach((): void => {
+    jest.clearAllMocks();
+    projectFindOneByMock.mockResolvedValue(projectRow());
+  });
+
+  async function resolveWith(
+    overrides?: Record<string, unknown>,
+  ): Promise<SessionReplayGatePolicy | null> {
+    appFindOneByMock.mockResolvedValue(appRow(overrides));
+
+    return await SessionReplayGateCache.getPolicy({
+      projectId: PROJECT_ID,
+      appIdentifier: "checkout-web",
+    });
+  }
+
+  it("selects the column from RumApplication", async (): Promise<void> => {
+    await resolveWith();
+
+    expect(appFindOneByMock).toHaveBeenCalled();
+
+    const select: Record<string, unknown> = (
+      appFindOneByMock.mock.calls[0]?.[0] as { select: Record<string, unknown> }
+    ).select;
+
+    expect(select["sessionReplaySameOriginTracePropagation"]).toBe(true);
+
+    /* Next to the cross-origin list it complements, which is still read. */
+    expect(select["sessionReplayTracePropagationOrigins"]).toBe(true);
+  });
+
+  it("an explicit false turns it off", async (): Promise<void> => {
+    const policy: SessionReplayGatePolicy | null = await resolveWith({
+      sessionReplaySameOriginTracePropagation: false,
+    });
+
+    expect(policy).not.toBeNull();
+    expect(policy?.sameOriginTracePropagation).toBe(false);
+  });
+
+  it("an explicit true keeps it on", async (): Promise<void> => {
+    const policy: SessionReplayGatePolicy | null = await resolveWith({
+      sessionReplaySameOriginTracePropagation: true,
+    });
+
+    expect(policy?.sameOriginTracePropagation).toBe(true);
+  });
+
+  it("an absent column reads as the DB default, on", async (): Promise<void> => {
+    const policy: SessionReplayGatePolicy | null = await resolveWith();
+
+    expect(policy).not.toBeNull();
+    expect(policy?.sameOriginTracePropagation).toBe(true);
+  });
+
+  it("a null column reads as the DB default, on", async (): Promise<void> => {
+    const policy: SessionReplayGatePolicy | null = await resolveWith({
+      sessionReplaySameOriginTracePropagation: null,
+    });
+
+    expect(policy?.sameOriginTracePropagation).toBe(true);
+  });
+
+  it("is independent of the cross-origin list: empty origins still propagate same-origin", async (): Promise<void> => {
+    const policy: SessionReplayGatePolicy | null = await resolveWith({
+      sessionReplayTracePropagationOrigins: [],
+    });
+
+    expect(policy?.tracePropagationOrigins).toEqual([]);
+    expect(policy?.sameOriginTracePropagation).toBe(true);
+  });
+
+  it("switching it off leaves the cross-origin list alone", async (): Promise<void> => {
+    const policy: SessionReplayGatePolicy | null = await resolveWith({
+      sessionReplaySameOriginTracePropagation: false,
+      sessionReplayTracePropagationOrigins: ["https://api.example.com"],
+    });
+
+    expect(policy?.sameOriginTracePropagation).toBe(false);
+    expect(policy?.tracePropagationOrigins).toEqual([
+      "https://api.example.com",
+    ]);
+  });
+
+  it("a refused application yields no policy at all, so nothing can propagate", async (): Promise<void> => {
+    const policy: SessionReplayGatePolicy | null = await resolveWith({
+      isSessionReplayEnabled: false,
+      sessionReplaySameOriginTracePropagation: true,
+    });
+
+    expect(policy).toBeNull();
+  });
+});

package/Tests/Server/Utils/StartServerProtobufContentType.test.ts

@@ -0,0 +1,54 @@
+import {
+  PROTOBUF_CONTENT_TYPES,
+  isProtobufContentType,
+} from "../../../Server/Utils/StartServer";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The global body-parser chain decides by content type whether a body is
+ * read raw (a Buffer the protobuf handlers decode) or handed to the JSON
+ * parser. "application/proto" - the Connect protocol's spelling, posted by
+ * Grafana Alloy's pyroscope.write and pyroscope-dotnet v0.14+ - was missing,
+ * so those bodies fell through to the JSON parser, came out as {} and every
+ * Pyroscope push was answered 400 (GH#4037).
+ */
+describe("isProtobufContentType", () => {
+  test.each([
+    ["application/x-protobuf"],
+    ["application/protobuf"],
+    ["application/proto"],
+    ["application/proto; charset=binary"],
+    ["Application/Proto"],
+    ["APPLICATION/X-PROTOBUF"],
+    ["  application/proto  "],
+  ])("%s is protobuf", (contentType: string) => {
+    expect(isProtobufContentType(contentType)).toBe(true);
+  });
+
+  test.each([
+    [undefined],
+    [""],
+    ["application/json"],
+    ["application/octet-stream"],
+    ["multipart/form-data; boundary=x"],
+    ["application/grpc"],
+    ["application/connect+proto"],
+    ["application/protobuffer"],
+    ["text/plain; note=application/proto"],
+  ])("%s is not", (contentType: string | undefined) => {
+    expect(isProtobufContentType(contentType)).toBe(false);
+  });
+
+  /*
+   * The raw parser and the dispatch both read this one list. Whether a real
+   * application/proto body arrives as a Buffer is asserted end to end in
+   * App's PyroscopeDotnetIngest test, through the actual parser chain.
+   */
+  test("lists exactly the protobuf media types, Connect's included", () => {
+    expect(PROTOBUF_CONTENT_TYPES).toEqual([
+      "application/x-protobuf",
+      "application/protobuf",
+      "application/proto",
+    ]);
+  });
+});