@oneuptime/common 12.0.8 → 12.0.9

package/Server/Utils/Telemetry/EntityRegistry.ts

@@ -1,19 +1,25 @@
 import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import Host from "../../../Models/DatabaseModels/Host";
 import DatabaseService from "../../Services/DatabaseService";
 import Query from "../../Types/Database/Query";
 import Select from "../../Types/Database/Select";
 import QueryDeepPartialEntity from "../../../Types/Database/PartialEntity";
 import ObjectID from "../../../Types/ObjectID";
 import EntityType from "../../../Types/Telemetry/EntityType";
+import EntitySource from "../../../Types/Telemetry/EntitySource";
+import LIMIT_MAX from "../../../Types/Database/LimitMax";
 import GlobalCache from "../../Infrastructure/GlobalCache";
+import HostService from "../../Services/HostService";
 import logger from "../Logger";
-import { ExtractedEntity } from "./TelemetryEntity";
-import TelemetryEntityService from "../../Services/TelemetryEntityService";
-import TelemetryEntityRelationshipService from "../../Services/TelemetryEntityRelationshipService";
+import { ExtractedEntity, RetiredEntityIdentity } from "./TelemetryEntity";
+import InventoryItemService from "../../Services/InventoryItemService";
+import InventoryItemRelationshipService from "../../Services/InventoryItemRelationshipService";
+import QueryHelper from "../../Types/Database/QueryHelper";
 import {
   deriveRelationships,
   EntityRelationshipEdge,
 } from "../../../Utils/Telemetry/EntityRelationship";
+import { canonicalizeEntityValue } from "../../../Utils/Telemetry/EntityKey";
 import crypto from "crypto";
 
 /*
@@ -90,6 +96,9 @@ const FENCE_NAMESPACE: string = "otel-maintenance-fence";
 const FENCE_SCOPE: string = "entity-reconcile";
 const ROW_FENCE_SCOPE: string = "entity-reconcile-row";
 const FENCE_TTL_SECONDS: number = 5 * 60; // 5 minutes
+const LEGACY_HOST_RETIREMENT_CACHE_NAMESPACE: string =
+  "legacy-kubernetes-host-retirement-completed";
+const LEGACY_HOST_RETIREMENT_CACHE_TTL_SECONDS: number = 24 * 60 * 60;
 
 /*
  * Atomic claim. A read-then-write here admits every worker that reads the
@@ -128,7 +137,7 @@ function hashFenceId(fenceId: string): string {
  *
  * The set-level fence keys on (project + the whole promoted entity set), which
  * in practice is unique per POD — a pod's own key is in the set. But the writes
- * it gates are per ROW: the single TelemetryEntity row for a Kubernetes cluster
+ * it gates are per ROW: the single InventoryItem row for a Kubernetes cluster
  * takes one UPDATE per pod in that cluster per window, the namespace row one
  * per pod in the namespace, and so on. Throttle granularity finer than write
  * granularity means the throttle does not bound the writes at all, and the
@@ -186,8 +195,8 @@ export async function shouldWarnEntityBudgetOnce(data: {
 }
 
 /*
- * Upsert discovered entities into the `TelemetryEntity` registry and their
- * co-occurrence edges into `TelemetryEntityRelationship`. Gated by a single
+ * Upsert discovered entities into the `InventoryItem` registry and their
+ * co-occurrence edges into `InventoryItemRelationship`. Gated by a single
  * per-batch Redis fence keyed on the PROMOTED entity subset, so a stable
  * resource reconciles at most once per window while a changed set (e.g. a
  * pod reschedule) reconciles immediately — and the high-churn
@@ -203,6 +212,7 @@ export async function shouldWarnEntityBudgetOnce(data: {
 export async function reconcileEntityRegistryThrottled(data: {
   projectId: ObjectID;
   entities: Array<ExtractedEntity>;
+  retiredEntities?: Array<RetiredEntityIdentity> | undefined;
 }): Promise<void> {
   try {
     const promoted: Array<ExtractedEntity> = data.entities.filter(
@@ -210,27 +220,47 @@ export async function reconcileEntityRegistryThrottled(data: {
         return REGISTRY_PROMOTED_TYPES.has(entity.entityType);
       },
     );
+    const retiredHosts: Array<RetiredEntityIdentity> = (
+      data.retiredEntities || []
+    ).filter((entity: RetiredEntityIdentity) => {
+      /*
+       * This repair path is intentionally closed over the one historical bug
+       * it can prove. A future caller cannot turn the generic-looking payload
+       * into a broad deletion primitive for another entity type.
+       */
+      return entity.entityType === EntityType.Host;
+    });
 
-    if (promoted.length === 0) {
+    if (promoted.length === 0 && retiredHosts.length === 0) {
       return;
     }
 
-    const fenceId: string = `${data.projectId.toString()}:${promoted
-      .map((entity: ExtractedEntity) => {
+    const fenceMembers: Array<string> = [
+      ...promoted.map((entity: ExtractedEntity) => {
         return entity.entityKey;
-      })
-      .sort()
-      .join(",")}`;
+      }),
+      ...retiredHosts.map((entity: RetiredEntityIdentity) => {
+        return `retire:${entity.entityType}:${entity.entityKey}`;
+      }),
+    ].sort();
+    const fenceId: string = `${data.projectId.toString()}:${fenceMembers.join(",")}`;
 
     if (!(await shouldReconcile(fenceId))) {
       return;
     }
 
-    await TelemetryEntityService.reconcileEntities({
+    await retireEntityRegistryIdentitiesBestEffort({
       projectId: data.projectId,
-      entities: promoted,
+      retiredEntities: retiredHosts,
     });
 
+    if (promoted.length > 0) {
+      await InventoryItemService.reconcileEntities({
+        projectId: data.projectId,
+        entities: promoted,
+      });
+    }
+
     /*
      * Topology (phase 5): the co-occurrence edges derive from the same
      * entity set, so they reconcile under the same fence — no extra
@@ -246,7 +276,7 @@ export async function reconcileEntityRegistryThrottled(data: {
       }),
     );
     if (edges.length > 0) {
-      await TelemetryEntityRelationshipService.reconcileRelationships({
+      await InventoryItemRelationshipService.reconcileRelationships({
         projectId: data.projectId,
         edges,
       });
@@ -257,10 +287,167 @@ export async function reconcileEntityRegistryThrottled(data: {
   }
 }
 
+/**
+ * Remove exact legacy discovered Host rows proven obsolete by the current
+ * resource observation, plus discovered topology edges that reference them.
+ *
+ * Every predicate is repeated at the delete boundary: tenant, type, key and
+ * source for InventoryItem; tenant, endpoint key and source for relationships.
+ * Manual and inventory-authored data is therefore unreachable even if a bad
+ * caller supplies its key. Failures are logged and swallowed so this optional
+ * repair can never delay or reject signal ingest.
+ */
+export async function retireEntityRegistryIdentitiesBestEffort(data: {
+  projectId: ObjectID;
+  retiredEntities: Array<RetiredEntityIdentity>;
+}): Promise<void> {
+  const seen: Set<string> = new Set<string>();
+
+  for (const retired of data.retiredEntities) {
+    if (retired.entityType !== EntityType.Host || seen.has(retired.entityKey)) {
+      continue;
+    }
+    seen.add(retired.entityKey);
+
+    const retirementCacheKey: string = `${data.projectId.toString()}:${retired.entityKey}`;
+    try {
+      if (
+        await GlobalCache.getString(
+          LEGACY_HOST_RETIREMENT_CACHE_NAMESPACE,
+          retirementCacheKey,
+        )
+      ) {
+        continue;
+      }
+    } catch (err) {
+      /* Cache maintenance must never become a signal-ingest dependency. */
+      logger.error(
+        `Entity registry: failed to read legacy Host retirement cache for ${retired.entityKey}; proceeding with repair: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+
+    const rawHostName: string | undefined =
+      retired.identifyingAttributes["host.name"];
+    const hostName: string = canonicalizeEntityValue(rawHostName || "");
+    if (!hostName) {
+      /*
+       * The key alone cannot establish which typed Host owns this identity.
+       * Fail closed instead of turning a malformed retirement into deletion.
+       */
+      logger.error(
+        `Entity registry: preserving legacy Host ${retired.entityKey} because its canonical host.name proof is missing`,
+      );
+      continue;
+    }
+
+    try {
+      const typedHost: Host | null = await HostService.findOneBy({
+        query: {
+          projectId: data.projectId,
+          hostIdentifier: QueryHelper.findWithSameText(hostName),
+        },
+        select: { _id: true },
+        props: { isRoot: true },
+      });
+
+      if (typedHost) {
+        /*
+         * A real Host with this canonical identifier makes the discovered
+         * registry Host legitimate, even when this particular observation is
+         * Kubernetes telemetry. Preserve it and cache that safe resolution.
+         */
+        await markLegacyHostRetirementCompletedBestEffort({
+          retirementCacheKey,
+          entityKey: retired.entityKey,
+        });
+        continue;
+      }
+    } catch (err) {
+      /* A lookup outage is uncertainty; uncertainty must preserve data. */
+      logger.error(
+        `Entity registry: preserving legacy Host ${retired.entityKey} because typed Host lookup failed: ${err instanceof Error ? err.message : String(err)}`,
+      );
+      continue;
+    }
+
+    try {
+      await InventoryItemService.hardDeleteBy({
+        query: {
+          projectId: data.projectId,
+          entityType: EntityType.Host,
+          entityKey: retired.entityKey,
+          source: EntitySource.Discovered,
+        },
+        limit: 1,
+        skip: 0,
+        props: { isRoot: true },
+      });
+    } catch (err) {
+      /*
+       * Keep its edges if the endpoint delete did not complete. That is less
+       * surprising than erasing topology for a row that remains visible.
+       */
+      logger.error(
+        `Entity registry: failed to retire legacy Kubernetes Host ${retired.entityKey}: ${err instanceof Error ? err.message : String(err)}`,
+      );
+      continue;
+    }
+
+    let retirementCompleted: boolean = true;
+    for (const direction of ["fromEntityKey", "toEntityKey"] as const) {
+      try {
+        let deleted: number = 0;
+        do {
+          deleted = await InventoryItemRelationshipService.hardDeleteBy({
+            query: {
+              projectId: data.projectId,
+              [direction]: retired.entityKey,
+              source: EntitySource.Discovered,
+            },
+            limit: LIMIT_MAX,
+            skip: 0,
+            props: { isRoot: true },
+          });
+        } while (deleted > 0);
+      } catch (err) {
+        retirementCompleted = false;
+        logger.error(
+          `Entity registry: failed to remove ${direction === "fromEntityKey" ? "outgoing" : "incoming"} relationships for retired Host ${retired.entityKey}: ${err instanceof Error ? err.message : String(err)}`,
+        );
+      }
+    }
+
+    if (retirementCompleted) {
+      await markLegacyHostRetirementCompletedBestEffort({
+        retirementCacheKey,
+        entityKey: retired.entityKey,
+      });
+    }
+  }
+}
+
+async function markLegacyHostRetirementCompletedBestEffort(data: {
+  retirementCacheKey: string;
+  entityKey: string;
+}): Promise<void> {
+  try {
+    await GlobalCache.setString(
+      LEGACY_HOST_RETIREMENT_CACHE_NAMESPACE,
+      data.retirementCacheKey,
+      "1",
+      { expiresInSeconds: LEGACY_HOST_RETIREMENT_CACHE_TTL_SECONDS },
+    );
+  } catch (err) {
+    logger.error(
+      `Entity registry: failed to cache completed legacy Host retirement for ${data.entityKey}: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+}
+
 /*
  * Find-or-create by natural key, bumping `lastSeenAt` — the one upsert
- * scaffold shared by TelemetryEntityService and
- * TelemetryEntityRelationshipService. Both tables have a unique index on
+ * scaffold shared by InventoryItemService and
+ * InventoryItemRelationshipService. Both tables have a unique index on
  * their natural key, so a concurrent first-contact create loses the race
  * with a unique-violation: in that case the winning row is re-fetched and
  * its `lastSeenAt` bumped immediately (instead of waiting a full throttle
@@ -331,7 +518,7 @@ export async function reconcileByNaturalKey<
     /*
      * Throttled bump of lastSeenAt (+ any caller-supplied merge fields).
      * Heartbeat write: single-statement UPDATE, no hooks and no `version`
-     * bump (TelemetryEntity/Relationship enable no update workflow/realtime/
+     * bump (InventoryItem/Relationship enable no update workflow/realtime/
      * audit). buildBump returns only plain values — lastSeenAt plus, at most,
      * the descriptiveAttributes / labels JSON columns — which the primitive
      * persists via the driver transformer path. See ServiceService.updateLastSeen.

package/Server/Utils/Telemetry/InventoryEntityRegistry.ts

@@ -1,5 +1,5 @@
 import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
-import TelemetryEntity from "../../../Models/DatabaseModels/TelemetryEntity";
+import InventoryItem from "../../../Models/DatabaseModels/InventoryItem";
 import CloudResource from "../../../Models/DatabaseModels/CloudResource";
 import DockerHost from "../../../Models/DatabaseModels/DockerHost";
 import IoTDevice from "../../../Models/DatabaseModels/IoTDevice";
@@ -15,7 +15,7 @@ import NetworkDeviceService from "../../Services/NetworkDeviceService";
 import PodmanHostService from "../../Services/PodmanHostService";
 import RumApplicationService from "../../Services/RumApplicationService";
 import ServerlessFunctionService from "../../Services/ServerlessFunctionService";
-import TelemetryEntityService from "../../Services/TelemetryEntityService";
+import InventoryItemService from "../../Services/InventoryItemService";
 import Query from "../../Types/Database/Query";
 import QueryHelper from "../../Types/Database/QueryHelper";
 import Select from "../../Types/Database/Select";
@@ -34,7 +34,7 @@ import {
 import logger from "../Logger";
 
 /*
- * Mirrors OneUptime's inventory tables into the TelemetryEntity registry.
+ * Mirrors OneUptime's inventory tables into the InventoryItem registry.
  *
  * The registry began as a projection of OTLP resource attributes, which is
  * why the entity explorer shows a Kubernetes pod but not the switch next to
@@ -87,7 +87,7 @@ export interface InventoryRowProjection {
  */
 export interface ErasedInventorySource {
   entityType: EntityType;
-  /** Model name stored in TelemetryEntity.resourceType. */
+  /** Model name stored in InventoryItem.resourceType. */
   resourceType: string;
   fetchPage(data: {
     skip: number;
@@ -149,10 +149,10 @@ export function buildInventoryEntityModel(data: {
   source: Pick<ErasedInventorySource, "entityType" | "resourceType">;
   row: InventoryRowProjection;
   now: Date;
-}): TelemetryEntity {
+}): InventoryItem {
   const { source, row, now } = data;
 
-  const model: TelemetryEntity = new TelemetryEntity();
+  const model: InventoryItem = new InventoryItem();
   model.projectId = row.projectId;
   model.entityType = source.entityType;
   model.entityKey = keyForInventoryEntity(
@@ -194,8 +194,8 @@ export function buildInventoryEntityModel(data: {
  * steady-state reconcile issues no writes at all.
  */
 export function inventoryEntityNeedsUpdate(data: {
-  existing: TelemetryEntity;
-  desired: TelemetryEntity;
+  existing: InventoryItem;
+  desired: InventoryItem;
 }): boolean {
   const { existing, desired } = data;
 
@@ -221,8 +221,8 @@ export function inventoryEntityNeedsUpdate(data: {
  * The columns a drifted mirror rewrites.
  *
  * Built as a plain shape and cast once, for the same two reasons as
- * TelemetryEntityService.buildDescriptiveUpdate: assigning into
- * `QueryDeepPartialEntity<TelemetryEntity>` directly makes TS instantiate the
+ * InventoryItemService.buildDescriptiveUpdate: assigning into
+ * `QueryDeepPartialEntity<InventoryItem>` directly makes TS instantiate the
  * recursive JSONObject mapping (TS2589), and under this project's
  * `exactOptionalPropertyTypes` an optional model field typed `string |
  * undefined` is not assignable to the update type at all. Keys are therefore
@@ -231,8 +231,8 @@ export function inventoryEntityNeedsUpdate(data: {
  * not "null it out".
  */
 function buildMirrorUpdate(
-  desired: TelemetryEntity,
-): QueryDeepPartialEntity<TelemetryEntity> {
+  desired: InventoryItem,
+): QueryDeepPartialEntity<InventoryItem> {
   const update: {
     displayName?: string;
     descriptiveAttributes?: JSONObject;
@@ -256,7 +256,7 @@ function buildMirrorUpdate(
     update.resourceId = desired.resourceId;
   }
 
-  return update as unknown as QueryDeepPartialEntity<TelemetryEntity>;
+  return update as unknown as QueryDeepPartialEntity<InventoryItem>;
 }
 
 function defineInventorySource<TModel extends BaseModel>(
@@ -494,13 +494,13 @@ async function mirrorRows(
 
     const now: Date = OneUptimeDate.getCurrentDate();
 
-    const desiredByKey: Map<string, TelemetryEntity> = new Map<
+    const desiredByKey: Map<string, InventoryItem> = new Map<
       string,
-      TelemetryEntity
+      InventoryItem
     >();
 
     for (const row of rows) {
-      const model: TelemetryEntity = buildInventoryEntityModel({
+      const model: InventoryItem = buildInventoryEntityModel({
         source,
         row,
         now,
@@ -508,8 +508,8 @@ async function mirrorRows(
       desiredByKey.set(model.entityKey!, model);
     }
 
-    const existingRows: Array<TelemetryEntity> =
-      await TelemetryEntityService.findBy({
+    const existingRows: Array<InventoryItem> =
+      await InventoryItemService.findBy({
         query: {
           entityType: source.entityType,
           entityKey: QueryHelper.any(Array.from(desiredByKey.keys())),
@@ -527,20 +527,20 @@ async function mirrorRows(
         props: { isRoot: true },
       });
 
-    const existingByKey: Map<string, TelemetryEntity> = new Map<
+    const existingByKey: Map<string, InventoryItem> = new Map<
       string,
-      TelemetryEntity
+      InventoryItem
     >();
     for (const existing of existingRows) {
       existingByKey.set(existing.entityKey!, existing);
     }
 
     for (const [key, desired] of desiredByKey.entries()) {
-      const existing: TelemetryEntity | undefined = existingByKey.get(key);
+      const existing: InventoryItem | undefined = existingByKey.get(key);
 
       try {
         if (!existing) {
-          await TelemetryEntityService.create({
+          await InventoryItemService.create({
             data: desired,
             props: { isRoot: true },
           });
@@ -549,7 +549,7 @@ async function mirrorRows(
         }
 
         if (inventoryEntityNeedsUpdate({ existing, desired })) {
-          await TelemetryEntityService.updateOneById({
+          await InventoryItemService.updateOneById({
             id: existing.id!,
             data: buildMirrorUpdate(desired),
             props: { isRoot: true },
@@ -591,7 +591,7 @@ async function removeOrphans(source: ErasedInventorySource): Promise<number> {
    * paging would shift subsequent offsets and skip rows.
    */
   for (;;) {
-    const rows: Array<TelemetryEntity> = await TelemetryEntityService.findBy({
+    const rows: Array<InventoryItem> = await InventoryItemService.findBy({
       query: {
         entityType: source.entityType,
         source: EntitySource.Inventory,
@@ -636,7 +636,7 @@ async function removeOrphans(source: ErasedInventorySource): Promise<number> {
     return 0;
   }
 
-  await TelemetryEntityService.hardDeleteBy({
+  await InventoryItemService.hardDeleteBy({
     query: {
       _id: QueryHelper.any(
         orphanIds.map((id: ObjectID) => {