@oneuptime/common 12.0.34 → 13.0.0

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

@@ -0,0 +1,316 @@
+import InventoryItem, {
+  EntityAttributes,
+  ExtractedEntity,
+  ResourceEntityRef,
+} from "../../../../Server/Utils/Telemetry/TelemetryEntity";
+import EntityType from "../../../../Types/Telemetry/EntityType";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * Regression suite for duplicate Inventory items.
+ *
+ * `InventoryItem` has a unique index on (projectId, entityType, entityKey),
+ * so two rows of the same type in one project can only mean one thing: the
+ * same real object hashed to two different keys. Nothing downstream can undo
+ * that — the two rows are, as far as the registry is concerned, two things —
+ * and because both keep being observed, neither ever ages out. The Inventory
+ * list then shows a node, pod or service twice, both marked Discovered, both
+ * with the same name, because the display name is derived from the attributes
+ * the two identities SHARE rather than the ones that differ.
+ *
+ * The rule these tests exist to hold: an entity's identity must depend only on
+ * WHICH OBJECT is being described, never on WHICH PIPELINE is describing it.
+ * Every case below is a pair of resources that our own shipped configuration
+ * produces for one object, differing only in what the producing collector was
+ * able to resolve.
+ */
+
+const PROJECT: string = "proj-dup-1";
+
+function entitiesFor(
+  attrs: EntityAttributes,
+  entityRefs?: Array<ResourceEntityRef>,
+): Array<ExtractedEntity> {
+  return InventoryItem.extractEntities({
+    projectId: PROJECT,
+    attributes: attrs,
+    ...(entityRefs ? { entityRefs } : {}),
+  });
+}
+
+function entityOfType(
+  attrs: EntityAttributes,
+  type: EntityType,
+): ExtractedEntity | undefined {
+  return entitiesFor(attrs).find((e: ExtractedEntity) => {
+    return e.entityType === type;
+  });
+}
+
+function keyOfType(attrs: EntityAttributes, type: EntityType): string {
+  const entity: ExtractedEntity | undefined = entityOfType(attrs, type);
+  expect(entity).toBeDefined();
+  return entity!.entityKey;
+}
+
+const CLUSTER: string = "prod-us";
+
+/*
+ * The two collectors the `kubernetes-agent` chart installs, reduced to the
+ * resource attributes each actually carries for the SAME node.
+ *
+ * Deployment / metrics-collector: the `k8s_cluster` receiver reports node
+ * metrics (`k8s.node.condition_ready`, allocatable cpu/memory/storage) and
+ * resolves node uids from the Kubernetes API.
+ *
+ * DaemonSet / node-collector: kubeletstats, hostmetrics, the cAdvisor scrape
+ * and the pod filelog receiver. None of them can produce a node uid — the
+ * kubelet summary API has no such field and `k8sattributes` is not asked to
+ * extract one — so the chart stamps `k8s.node.name` from the downward API
+ * instead.
+ */
+const NODE_FROM_K8S_CLUSTER_RECEIVER: EntityAttributes = {
+  "k8s.cluster.name": CLUSTER,
+  "k8s.node.name": "ip-10-0-1-23.ec2.internal",
+  "k8s.node.uid": "a8170da5-c826-49b0-b48b-a35af366e689",
+  "service.name": `kubernetes-agent-${CLUSTER}`,
+};
+
+const NODE_FROM_DAEMONSET: EntityAttributes = {
+  "k8s.cluster.name": CLUSTER,
+  "k8s.node.name": "ip-10-0-1-23.ec2.internal",
+  "service.name": `kubernetes-agent-${CLUSTER}`,
+};
+
+/*
+ * The same pod as seen by the deployment collector (k8sattributes resolves
+ * `k8s.pod.uid`) and by a pod-log record that only carries the pod name.
+ */
+const POD_WITH_UID: EntityAttributes = {
+  "k8s.cluster.name": CLUSTER,
+  "k8s.namespace.name": "shop",
+  "k8s.pod.name": "checkout-api-7d9f884c7d-q5bz2",
+  "k8s.pod.uid": "7c2f9dd0-8400-4c47-9c54-321ebeb9543b",
+};
+
+const POD_WITHOUT_UID: EntityAttributes = {
+  "k8s.cluster.name": CLUSTER,
+  "k8s.namespace.name": "shop",
+  "k8s.pod.name": "checkout-api-7d9f884c7d-q5bz2",
+};
+
+describe("one object, one identity, whichever collector saw it", () => {
+  test("a node reported with a uid and the same node reported without one are one entity", () => {
+    expect(
+      keyOfType(NODE_FROM_K8S_CLUSTER_RECEIVER, EntityType.KubernetesNode),
+    ).toBe(keyOfType(NODE_FROM_DAEMONSET, EntityType.KubernetesNode));
+  });
+
+  test("a pod reported with a uid and the same pod reported without one are one entity", () => {
+    expect(keyOfType(POD_WITH_UID, EntityType.KubernetesPod)).toBe(
+      keyOfType(POD_WITHOUT_UID, EntityType.KubernetesPod),
+    );
+  });
+
+  test("node identity is the cluster plus the node name, and nothing else", () => {
+    expect(
+      entityOfType(NODE_FROM_K8S_CLUSTER_RECEIVER, EntityType.KubernetesNode)!
+        .identifyingAttributes,
+    ).toEqual({
+      "k8s.cluster.name": CLUSTER,
+      "k8s.node.name": "ip-10-0-1-23.ec2.internal",
+    });
+  });
+
+  test("pod identity is the cluster, namespace and pod name, and nothing else", () => {
+    expect(
+      entityOfType(POD_WITH_UID, EntityType.KubernetesPod)!
+        .identifyingAttributes,
+    ).toEqual({
+      "k8s.cluster.name": CLUSTER,
+      "k8s.namespace.name": "shop",
+      "k8s.pod.name": "checkout-api-7d9f884c7d-q5bz2",
+    });
+  });
+
+  test("the uid is still recorded, just not as identity", () => {
+    expect(
+      entityOfType(NODE_FROM_K8S_CLUSTER_RECEIVER, EntityType.KubernetesNode)!
+        .descriptiveAttributes,
+    ).toMatchObject({
+      "k8s.node.uid": "a8170da5-c826-49b0-b48b-a35af366e689",
+    });
+    expect(
+      entityOfType(POD_WITH_UID, EntityType.KubernetesPod)!
+        .descriptiveAttributes,
+    ).toMatchObject({
+      "k8s.pod.uid": "7c2f9dd0-8400-4c47-9c54-321ebeb9543b",
+    });
+  });
+
+  test("a pod that keeps its name across a restart keeps its inventory row", () => {
+    /*
+     * A StatefulSet pod is recreated under the same name with a fresh uid.
+     * Under uid identity that minted a new registry row per incarnation; the
+     * name is what an inventory is actually tracking.
+     */
+    const before: string = keyOfType(POD_WITH_UID, EntityType.KubernetesPod);
+    const after: string = keyOfType(
+      {
+        ...POD_WITH_UID,
+        "k8s.pod.uid": "0000aaaa-1111-2222-3333-444455556666",
+      },
+      EntityType.KubernetesPod,
+    );
+
+    expect(after).toBe(before);
+  });
+});
+
+describe("identity that genuinely differs must stay different", () => {
+  test("the same node name in two clusters is two entities", () => {
+    expect(keyOfType(NODE_FROM_DAEMONSET, EntityType.KubernetesNode)).not.toBe(
+      keyOfType(
+        { ...NODE_FROM_DAEMONSET, "k8s.cluster.name": "prod-eu" },
+        EntityType.KubernetesNode,
+      ),
+    );
+  });
+
+  test("the same pod name in two namespaces is two entities", () => {
+    expect(keyOfType(POD_WITHOUT_UID, EntityType.KubernetesPod)).not.toBe(
+      keyOfType(
+        { ...POD_WITHOUT_UID, "k8s.namespace.name": "checkout" },
+        EntityType.KubernetesPod,
+      ),
+    );
+  });
+
+  test("the same pod name in two clusters is two entities", () => {
+    expect(keyOfType(POD_WITHOUT_UID, EntityType.KubernetesPod)).not.toBe(
+      keyOfType(
+        { ...POD_WITHOUT_UID, "k8s.cluster.name": "prod-eu" },
+        EntityType.KubernetesPod,
+      ),
+    );
+  });
+
+  test("two different nodes in one cluster are two entities", () => {
+    expect(keyOfType(NODE_FROM_DAEMONSET, EntityType.KubernetesNode)).not.toBe(
+      keyOfType(
+        {
+          ...NODE_FROM_DAEMONSET,
+          "k8s.node.name": "ip-10-0-1-24.ec2.internal",
+        },
+        EntityType.KubernetesNode,
+      ),
+    );
+  });
+
+  test("a uid-only node and a named node are not silently merged", () => {
+    /*
+     * Nothing can prove these are the same object from the resource alone, so
+     * they stay distinct. The uid-only shape exists only for a producer that
+     * carries no name at all.
+     */
+    expect(
+      keyOfType(
+        { "k8s.cluster.name": CLUSTER, "k8s.node.uid": "node-uid-only" },
+        EntityType.KubernetesNode,
+      ),
+    ).not.toBe(keyOfType(NODE_FROM_DAEMONSET, EntityType.KubernetesNode));
+  });
+});
+
+describe("casing and whitespace do not fork identity", () => {
+  test.each([
+    ["upper-cased node name", { "k8s.node.name": "IP-10-0-1-23.EC2.INTERNAL" }],
+    ["padded node name", { "k8s.node.name": "  ip-10-0-1-23.ec2.internal  " }],
+    ["upper-cased cluster", { "k8s.cluster.name": "PROD-US" }],
+  ])(
+    "%s resolves to the same node entity",
+    (_label: string, override: EntityAttributes) => {
+      expect(
+        keyOfType(
+          { ...NODE_FROM_DAEMONSET, ...override },
+          EntityType.KubernetesNode,
+        ),
+      ).toBe(keyOfType(NODE_FROM_DAEMONSET, EntityType.KubernetesNode));
+    },
+  );
+});
+
+describe("one resource describes at most one entity per type", () => {
+  /*
+   * A resource is one pod, on one node, in one cluster. `entity_refs` are
+   * producer-supplied and nothing stops a producer sending two refs of the
+   * same type on one resource; promoting both put two Inventory rows in from
+   * a single batch. The extra ref stays a membership key so no signal loses
+   * its queryable identity.
+   */
+  const TWO_POD_REFS: Array<ResourceEntityRef> = [
+    { type: "k8s.pod", idKeys: ["k8s.pod.name"] },
+    { type: "k8s.pod", idKeys: ["k8s.pod.uid"] },
+  ];
+
+  test("only the first ref of a type is promoted to a registry row", () => {
+    const pods: Array<ExtractedEntity> = entitiesFor(
+      POD_WITH_UID,
+      TWO_POD_REFS,
+    ).filter((e: ExtractedEntity) => {
+      return e.entityType === EntityType.KubernetesPod;
+    });
+
+    expect(pods).toHaveLength(2);
+    expect(
+      pods.filter((p: ExtractedEntity) => {
+        return !p.membershipOnly;
+      }),
+    ).toHaveLength(1);
+  });
+
+  test("the demoted ref keeps its key so signals stay queryable by it", () => {
+    const pods: Array<ExtractedEntity> = entitiesFor(
+      POD_WITH_UID,
+      TWO_POD_REFS,
+    ).filter((e: ExtractedEntity) => {
+      return e.entityType === EntityType.KubernetesPod;
+    });
+
+    const keys: Array<string> = pods.map((p: ExtractedEntity) => {
+      return p.entityKey;
+    });
+
+    expect(new Set(keys).size).toBe(2);
+    expect(
+      InventoryItem.extractEntityKeys({
+        projectId: PROJECT,
+        attributes: POD_WITH_UID,
+        entityRefs: TWO_POD_REFS,
+      }),
+    ).toEqual(expect.arrayContaining(keys));
+  });
+
+  test("refs of different types are all promoted", () => {
+    const entities: Array<ExtractedEntity> = entitiesFor(POD_WITH_UID, [
+      { type: "k8s.pod", idKeys: ["k8s.pod.name"] },
+      { type: "k8s.namespace", idKeys: ["k8s.namespace.name"] },
+    ]);
+
+    expect(
+      entities.filter((e: ExtractedEntity) => {
+        return !e.membershipOnly;
+      }),
+    ).toHaveLength(2);
+  });
+
+  test("the heuristic resolvers already emit one entity per type", () => {
+    const types: Array<EntityType> = entitiesFor(POD_WITH_UID).map(
+      (e: ExtractedEntity) => {
+        return e.entityType;
+      },
+    );
+
+    expect(new Set(types).size).toBe(types.length);
+  });
+});

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

@@ -750,7 +750,7 @@ describe("descriptive attributes & labels (never identity-bearing)", () => {
       name: "worker-1",
     },
   ])(
-    "k8s.$label: keeps the stable UID identity and carries the name descriptively",
+    "k8s.$label: keys on the name and carries the UID descriptively",
     ({
       type,
       uidKey,
@@ -765,19 +765,122 @@ describe("descriptive attributes & labels (never identity-bearing)", () => {
       nameKey: string;
       name: string;
     }) => {
-      const uidOnly: ExtractedEntity | undefined = entityOfType(
-        { [uidKey]: uid },
-        type,
-      );
       const named: ExtractedEntity | undefined = entityOfType(
         { [uidKey]: uid, [nameKey]: name },
         type,
       );
 
       expect(named).toBeDefined();
-      expect(named!.entityKey).toBe(uidOnly!.entityKey);
-      expect(named!.identifyingAttributes).toEqual({ [uidKey]: uid });
-      expect(named!.descriptiveAttributes).toEqual({ [nameKey]: name });
+      expect(named!.identifyingAttributes).toEqual({ [nameKey]: name });
+      /*
+       * The name is carried descriptively as well as identifying it. That is
+       * deliberate: `buildDescriptiveUpdate` reads the display name out of
+       * the descriptive bag first, so a row whose identity later changes
+       * shape still has a name to show.
+       */
+      expect(named!.descriptiveAttributes).toEqual({
+        [nameKey]: name,
+        [uidKey]: uid,
+      });
+    },
+  );
+
+  /*
+   * The regression test for duplicate Inventory rows.
+   *
+   * The shipped Kubernetes agent runs two collectors over the same nodes and
+   * pods. The Deployment's `k8s_cluster` receiver resolves uids; the
+   * DaemonSet's kubeletstats / hostmetrics / cAdvisor / filelog receivers
+   * never do. Identity must not depend on which of them is talking.
+   */
+  test.each([
+    {
+      label: "node",
+      type: EntityType.KubernetesNode,
+      withUid: {
+        "k8s.cluster.name": "prod-us",
+        "k8s.node.name": "worker-1",
+        "k8s.node.uid": "node-uid-1",
+      },
+      withoutUid: {
+        "k8s.cluster.name": "prod-us",
+        "k8s.node.name": "worker-1",
+      },
+    },
+    {
+      label: "pod",
+      type: EntityType.KubernetesPod,
+      withUid: {
+        "k8s.cluster.name": "prod-us",
+        "k8s.namespace.name": "shop",
+        "k8s.pod.name": "checkout-7d9f",
+        "k8s.pod.uid": "pod-uid-1",
+      },
+      withoutUid: {
+        "k8s.cluster.name": "prod-us",
+        "k8s.namespace.name": "shop",
+        "k8s.pod.name": "checkout-7d9f",
+      },
+    },
+  ])(
+    "k8s.$label: a producer that resolves the UID and one that does not agree on identity",
+    ({
+      type,
+      withUid,
+      withoutUid,
+    }: {
+      label: string;
+      type: EntityType;
+      withUid: EntityAttributes;
+      withoutUid: EntityAttributes;
+    }) => {
+      const resolved: ExtractedEntity | undefined = entityOfType(withUid, type);
+      const unresolved: ExtractedEntity | undefined = entityOfType(
+        withoutUid,
+        type,
+      );
+
+      expect(resolved).toBeDefined();
+      expect(unresolved).toBeDefined();
+      expect(resolved!.entityKey).toBe(unresolved!.entityKey);
+      expect(resolved!.identifyingAttributes).toEqual(
+        unresolved!.identifyingAttributes,
+      );
+    },
+  );
+
+  test.each([
+    {
+      label: "node",
+      type: EntityType.KubernetesNode,
+      uidKey: "k8s.node.uid",
+      uid: "node-uid-1",
+    },
+    {
+      label: "pod",
+      type: EntityType.KubernetesPod,
+      uidKey: "k8s.pod.uid",
+      uid: "pod-uid-1",
+    },
+  ])(
+    "k8s.$label: falls back to the UID when the resource carries no name",
+    ({
+      type,
+      uidKey,
+      uid,
+    }: {
+      label: string;
+      type: EntityType;
+      uidKey: string;
+      uid: string;
+    }) => {
+      const entity: ExtractedEntity | undefined = entityOfType(
+        { [uidKey]: uid },
+        type,
+      );
+
+      expect(entity).toBeDefined();
+      expect(entity!.identifyingAttributes).toEqual({ [uidKey]: uid });
     },
   );
 

package/Tests/Types/Database/IncludesAnyOfGroups.test.ts

@@ -0,0 +1,106 @@
+import IncludesAnyOfGroups from "../../../Types/BaseDatabase/IncludesAnyOfGroups";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import { JSONObject, ObjectType } from "../../../Types/JSON";
+import JSONFunctions from "../../../Types/JSONFunctions";
+import SerializableObjectDictionary from "../../../Types/SerializableObjectDictionary";
+
+describe("IncludesAnyOfGroups", () => {
+  test("preserves group boundaries and removes duplicate ids within a group", () => {
+    const value: IncludesAnyOfGroups = new IncludesAnyOfGroups([
+      ["network", "router", "network"],
+      ["0660", "0661"],
+    ]);
+    expect(value.groups).toEqual([
+      ["network", "router"],
+      ["0660", "0661"],
+    ]);
+  });
+
+  test("retains empty groups so they can match nothing", () => {
+    expect(new IncludesAnyOfGroups([["network"], []]).groups).toEqual([
+      ["network"],
+      [],
+    ]);
+  });
+
+  test("owns its data and does not expose mutable validated groups", () => {
+    const groups: Array<Array<string>> = [["network"], ["0660"]];
+    const value: IncludesAnyOfGroups = new IncludesAnyOfGroups(groups);
+    groups[0]!.push("router");
+    value.groups[1]!.push("0661");
+    (value.toJSON()["value"] as Array<Array<string>>)[0]!.push("other");
+    expect(value.groups).toEqual([["network"], ["0660"]]);
+  });
+
+  test("round trips through the API JSON registry with leading zeros intact", () => {
+    const value: IncludesAnyOfGroups = new IncludesAnyOfGroups([
+      ["network"],
+      ["0660", "0661"],
+    ]);
+    const serialized: JSONObject = JSONFunctions.serialize({ labels: value });
+    expect(serialized["labels"]).toEqual({
+      _type: ObjectType.IncludesAnyOfGroups,
+      value: [["network"], ["0660", "0661"]],
+    });
+    const result: JSONObject = JSONFunctions.deserialize(
+      JSON.parse(JSON.stringify(serialized)),
+    ) as JSONObject;
+    expect(SerializableObjectDictionary[ObjectType.IncludesAnyOfGroups]).toBe(
+      IncludesAnyOfGroups,
+    );
+    expect(result["labels"]).toBeInstanceOf(IncludesAnyOfGroups);
+    expect((result["labels"] as IncludesAnyOfGroups).groups).toEqual(
+      value.groups,
+    );
+  });
+
+  test.each(
+    [
+      undefined,
+      null,
+      [],
+      "network",
+      ["network"],
+      [null],
+      [[null]],
+      [[1]],
+      [[{}]],
+      [[""]],
+      [["a".repeat(257)]],
+      Array.from({ length: 33 }, () => {
+        return ["id"];
+      }),
+      [
+        Array.from({ length: 1001 }, () => {
+          return "id";
+        }),
+      ],
+      Array.from({ length: 11 }, () => {
+        return Array.from({ length: 1000 }, () => {
+          return "id";
+        });
+      }),
+    ].map((groups: unknown) => {
+      return [groups];
+    }),
+  )("rejects invalid or oversized group data %#", (groups: unknown) => {
+    expect(() => {
+      return new IncludesAnyOfGroups(groups as Array<Array<string>>);
+    }).toThrow(BadDataException);
+    expect(() => {
+      return IncludesAnyOfGroups.fromJSON({
+        _type: ObjectType.IncludesAnyOfGroups,
+        value: groups,
+      } as JSONObject);
+    }).toThrow(BadDataException);
+  });
+
+  test("rejects a different operator type", () => {
+    expect(() => {
+      return IncludesAnyOfGroups.fromJSON({
+        _type: ObjectType.Includes,
+        value: [["network"]],
+      });
+    }).toThrow(BadDataException);
+  });
+});

package/Tests/Types/JSONFunctions.test.ts

@@ -484,6 +484,46 @@ describe("JSONFunctions Class", () => {
       }).toThrow("Expected JSONObject, but got JSONArray");
     });
 
+    /*
+     * An array was once the only shape refused, so every other non-object -
+     * all of them valid JSON - came back typed as a JSONObject and was read
+     * as one. The two callers that matter both did exactly that: the Text to
+     * JSON workflow component announced a bare number as a successful parse,
+     * and JSONWebToken.decodeJsonPayload took a string payload and read
+     * undefined out of every field of it.
+     */
+    test("parseJSONObject throws when given a bare number", () => {
+      expect(() => {
+        return JSONFunctions.parseJSONObject("42");
+      }).toThrow("Expected JSONObject, but got number");
+    });
+
+    test("parseJSONObject throws when given a bare string", () => {
+      expect(() => {
+        return JSONFunctions.parseJSONObject('"just a string"');
+      }).toThrow("Expected JSONObject, but got string");
+    });
+
+    test("parseJSONObject throws when given a bare boolean", () => {
+      expect(() => {
+        return JSONFunctions.parseJSONObject("true");
+      }).toThrow("Expected JSONObject, but got boolean");
+    });
+
+    test("parseJSONObject throws when given null", () => {
+      expect(() => {
+        return JSONFunctions.parseJSONObject("null");
+      }).toThrow("Expected JSONObject, but got null");
+    });
+
+    test("parseJSONObject still accepts an empty object", () => {
+      expect(JSONFunctions.parseJSONObject("{}")).toEqual({});
+    });
+
+    test("parseJSONObject still accepts JSON5 unquoted keys", () => {
+      expect(JSONFunctions.parseJSONObject("{ a: 1 }")).toEqual({ a: 1 });
+    });
+
     test("parseJSONArray returns an array", () => {
       expect(JSONFunctions.parseJSONArray("[1, 2]")).toEqual([1, 2]);
     });