@oneuptime/common 11.0.2 → 11.0.4

package/Server/Services/PodmanHostOwnerRuleEngineService.ts

@@ -0,0 +1,216 @@
+import Label from "../../Models/DatabaseModels/Label";
+import PodmanHost from "../../Models/DatabaseModels/PodmanHost";
+import PodmanHostOwnerRule from "../../Models/DatabaseModels/PodmanHostOwnerRule";
+import PodmanHostOwnerUser from "../../Models/DatabaseModels/PodmanHostOwnerUser";
+import PodmanHostOwnerTeam from "../../Models/DatabaseModels/PodmanHostOwnerTeam";
+import PodmanHostOwnerRuleService from "./PodmanHostOwnerRuleService";
+import PodmanHostOwnerUserService from "./PodmanHostOwnerUserService";
+import PodmanHostOwnerTeamService from "./PodmanHostOwnerTeamService";
+import PodmanHostService from "./PodmanHostService";
+import ObjectID from "../../Types/ObjectID";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger, { LogAttributes } from "../Utils/Logger";
+
+class PodmanHostOwnerRuleEngineServiceClass {
+  /**
+   * Evaluates PodmanHostOwnerRule rows for the given Podman host and adds matched
+   * owner users / teams via PodmanHostOwnerUserService / PodmanHostOwnerTeamService. Rules
+   * with notifyOwners set notify the added owners; rules with notifyOwners off
+   * add silently.
+   */
+  @CaptureSpan()
+  public async applyRulesToPodmanHost(podmanHost: PodmanHost): Promise<void> {
+    if (!podmanHost.id || !podmanHost.projectId) {
+      return;
+    }
+
+    try {
+      const rules: Array<PodmanHostOwnerRule> =
+        await PodmanHostOwnerRuleService.findBy({
+          query: {
+            projectId: podmanHost.projectId,
+            isEnabled: true,
+          },
+          props: { isRoot: true },
+          select: {
+            _id: true,
+            name: true,
+            notifyOwners: true,
+            podmanHostLabels: { _id: true },
+            podmanHostNamePattern: true,
+            podmanHostDescriptionPattern: true,
+            ownerUsers: { _id: true },
+            ownerTeams: { _id: true },
+          },
+          limit: 100,
+          skip: 0,
+        });
+
+      if (rules.length === 0) {
+        return;
+      }
+
+      const podmanHostWithDetails: PodmanHost | null =
+        await PodmanHostService.findOneById({
+          id: podmanHost.id,
+          select: {
+            name: true,
+            description: true,
+            labels: { _id: true },
+          },
+          props: { isRoot: true },
+        });
+
+      if (!podmanHostWithDetails) {
+        return;
+      }
+
+      const usersByNotify: Map<boolean, Set<string>> = new Map([
+        [true, new Set()],
+        [false, new Set()],
+      ]);
+      const teamsByNotify: Map<boolean, Set<string>> = new Map([
+        [true, new Set()],
+        [false, new Set()],
+      ]);
+
+      const matchedRules: Array<PodmanHostOwnerRule> = [];
+
+      for (const rule of rules) {
+        const matches: boolean = this.doesPodmanHostMatchRule(
+          podmanHostWithDetails,
+          rule,
+        );
+        if (!matches) {
+          continue;
+        }
+        let ruleAddedAny: boolean = false;
+        const notify: boolean = rule.notifyOwners !== false;
+        for (const user of rule.ownerUsers || []) {
+          if (user.id) {
+            usersByNotify.get(notify)!.add(user.id.toString());
+            ruleAddedAny = true;
+          }
+        }
+        for (const team of rule.ownerTeams || []) {
+          if (team.id) {
+            teamsByNotify.get(notify)!.add(team.id.toString());
+            ruleAddedAny = true;
+          }
+        }
+        if (ruleAddedAny) {
+          matchedRules.push(rule);
+        }
+      }
+
+      if (matchedRules.length === 0) {
+        return;
+      }
+
+      for (const notify of [true, false]) {
+        const userIds: Set<string> = usersByNotify.get(notify)!;
+        const teamIds: Set<string> = teamsByNotify.get(notify)!;
+
+        for (const userId of userIds) {
+          const owner: PodmanHostOwnerUser = new PodmanHostOwnerUser();
+          owner.podmanHostId = podmanHost.id;
+          owner.projectId = podmanHost.projectId;
+          owner.userId = new ObjectID(userId);
+          owner.isOwnerNotified = !notify;
+          await PodmanHostOwnerUserService.create({
+            data: owner,
+            props: { isRoot: true },
+          });
+        }
+
+        for (const teamId of teamIds) {
+          const owner: PodmanHostOwnerTeam = new PodmanHostOwnerTeam();
+          owner.podmanHostId = podmanHost.id;
+          owner.projectId = podmanHost.projectId;
+          owner.teamId = new ObjectID(teamId);
+          owner.isOwnerNotified = !notify;
+          await PodmanHostOwnerTeamService.create({
+            data: owner,
+            props: { isRoot: true },
+          });
+        }
+      }
+
+      logger.debug(
+        `PodmanHostOwnerRuleEngine added owners to Podman host ${podmanHost.id}`,
+        { projectId: podmanHost.projectId.toString() } as LogAttributes,
+      );
+    } catch (error) {
+      logger.error(`Error applying Podman host owner rules: ${error}`, {
+        projectId: podmanHost.projectId?.toString(),
+        podmanHostId: podmanHost.id?.toString(),
+      } as LogAttributes);
+    }
+  }
+
+  private doesPodmanHostMatchRule(
+    podmanHost: PodmanHost,
+    rule: PodmanHostOwnerRule,
+  ): boolean {
+    if (rule.podmanHostLabels && rule.podmanHostLabels.length > 0) {
+      if (!podmanHost.labels || podmanHost.labels.length === 0) {
+        return false;
+      }
+      const ruleLabelIds: Array<string> = rule.podmanHostLabels.map(
+        (l: Label) => {
+          return l.id?.toString() || "";
+        },
+      );
+      const labelIds: Array<string> = podmanHost.labels.map((l: Label) => {
+        return l.id?.toString() || "";
+      });
+      if (
+        !ruleLabelIds.some((id: string) => {
+          return labelIds.includes(id);
+        })
+      ) {
+        return false;
+      }
+    }
+
+    if (
+      rule.podmanHostNamePattern &&
+      (!podmanHost.name ||
+        !this.testRegex(rule.podmanHostNamePattern, podmanHost.name, rule))
+    ) {
+      return false;
+    }
+
+    if (
+      rule.podmanHostDescriptionPattern &&
+      (!podmanHost.description ||
+        !this.testRegex(
+          rule.podmanHostDescriptionPattern,
+          podmanHost.description,
+          rule,
+        ))
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+
+  private testRegex(
+    pattern: string,
+    value: string,
+    rule: PodmanHostOwnerRule,
+  ): boolean {
+    try {
+      const regex: RegExp = new RegExp(pattern, "i");
+      return regex.test(value);
+    } catch {
+      logger.warn(
+        `Invalid regex in Podman host owner rule ${rule.id}: ${pattern}`,
+      );
+      return false;
+    }
+  }
+}
+
+export default new PodmanHostOwnerRuleEngineServiceClass();

package/Server/Services/PodmanHostOwnerRuleService.ts

@@ -0,0 +1,14 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/PodmanHostOwnerRule";
+import { IsBillingEnabled } from "../EnvironmentConfig";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 3 * 365);
+    }
+  }
+}
+
+export default new Service();

package/Server/Services/PodmanHostOwnerTeamService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/PodmanHostOwnerTeam";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+
+export default new Service();

package/Server/Services/PodmanHostOwnerUserService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/PodmanHostOwnerUser";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+
+export default new Service();

package/Server/Services/PodmanHostService.ts

@@ -0,0 +1,368 @@
+import DatabaseService from "./DatabaseService";
+import PodmanHostLabelRuleEngineService from "./PodmanHostLabelRuleEngineService";
+import PodmanHostOwnerRuleEngineService from "./PodmanHostOwnerRuleEngineService";
+import Model from "../../Models/DatabaseModels/PodmanHost";
+import Label from "../../Models/DatabaseModels/Label";
+import { OnCreate } from "../Types/Database/Hooks";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import ObjectID from "../../Types/ObjectID";
+import QueryHelper from "../Types/Database/QueryHelper";
+import OneUptimeDate from "../../Types/Date";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import GlobalCache from "../Infrastructure/GlobalCache";
+import logger, { LogAttributes } from "../Utils/Logger";
+import crypto from "crypto";
+
+const LAST_SEEN_CACHE_NAMESPACE: string = "podman-host-last-seen";
+const LAST_SEEN_THROTTLE_SECONDS: number = 60;
+
+const LABELS_APPLIED_CACHE_NAMESPACE: string = "podman-host-labels-applied";
+const LABELS_APPLIED_CACHE_TTL_SECONDS: number = 60;
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  @CaptureSpan()
+  protected override async onCreateSuccess(
+    _onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    if (createdItem.projectId && createdItem.id) {
+      Promise.resolve()
+        .then(async () => {
+          await PodmanHostLabelRuleEngineService.applyRulesToPodmanHost(
+            createdItem,
+          );
+        })
+        .then(async () => {
+          await PodmanHostOwnerRuleEngineService.applyRulesToPodmanHost(
+            createdItem,
+          );
+        })
+        .catch((error: Error) => {
+          logger.error(
+            `Error applying podman host rules in PodmanHostService.onCreateSuccess: ${error}`,
+            {
+              projectId: createdItem.projectId?.toString(),
+              podmanHostId: createdItem.id?.toString(),
+            } as LogAttributes,
+          );
+        });
+    }
+    return createdItem;
+  }
+
+  @CaptureSpan()
+  public async findOrCreateByHostIdentifier(data: {
+    projectId: ObjectID;
+    hostIdentifier: string;
+  }): Promise<Model> {
+    /*
+     * Canonicalize + look up case-insensitively. A Podman host is keyed by
+     * the OTel `host.name` resource attribute (see autoDiscoverPodmanHost),
+     * whose casing is not stable — Windows surfaces PRIMARY01 vs primary01
+     * across resource detectors. Ingest already canonicalizes host.name
+     * (OtelIngestBaseService.normalizeHostNameAttributesInPlace); we repeat
+     * it here so the method is correct for any caller. A case-sensitive
+     * lookup would miss an existing row, then fail to create it because the
+     * unique guard (checkUniqueColumnBy -> findWithSameText) compares
+     * case-insensitively, wedging ingest for that host. Mirrors HostService.
+     */
+    const hostIdentifier: string = data.hostIdentifier.trim().toLowerCase();
+
+    const existingHost: Model | null = await this.findOneBy({
+      query: {
+        projectId: data.projectId,
+        hostIdentifier: QueryHelper.findWithSameText(hostIdentifier),
+      },
+      select: {
+        _id: true,
+        projectId: true,
+        hostIdentifier: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (existingHost) {
+      /*
+       * Converge a legacy mixed-case identifier onto the canonical form so
+       * the stored resource.host.name (canonicalized at ingest) keeps
+       * matching the Podman-host detail page filter. Best-effort — never
+       * block ingest on it. Updates don't re-run the unique guard.
+       */
+      if (
+        existingHost._id &&
+        existingHost.hostIdentifier &&
+        existingHost.hostIdentifier !== hostIdentifier
+      ) {
+        try {
+          await this.updateOneById({
+            id: new ObjectID(existingHost._id.toString()),
+            data: {
+              hostIdentifier: hostIdentifier,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+          existingHost.hostIdentifier = hostIdentifier;
+        } catch (err) {
+          logger.warn(
+            `PodmanHostService: failed to canonicalize hostIdentifier for host ${existingHost._id.toString()}: ${
+              err instanceof Error ? err.message : String(err)
+            }`,
+          );
+        }
+      }
+
+      return existingHost;
+    }
+
+    try {
+      // Create new host
+      const newHost: Model = new Model();
+      newHost.projectId = data.projectId;
+      newHost.name = hostIdentifier;
+      newHost.hostIdentifier = hostIdentifier;
+      newHost.otelCollectorStatus = "connected";
+      newHost.lastSeenAt = OneUptimeDate.getCurrentDate();
+
+      const createdHost: Model = await this.create({
+        data: newHost,
+        props: {
+          isRoot: true,
+        },
+      });
+
+      return createdHost;
+    } catch {
+      /*
+       * Either two ingest workers raced to create the same host, or a host
+       * with this identifier in a different case already existed and the
+       * unique guard rejected the insert. Re-resolve case-insensitively so
+       * the caller still gets the existing row instead of throwing.
+       */
+      const reFetchedHost: Model | null = await this.findOneBy({
+        query: {
+          projectId: data.projectId,
+          hostIdentifier: QueryHelper.findWithSameText(hostIdentifier),
+        },
+        select: {
+          _id: true,
+          projectId: true,
+          hostIdentifier: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (reFetchedHost) {
+        return reFetchedHost;
+      }
+
+      throw new Error(
+        "Failed to create or find Podman host: " + hostIdentifier,
+      );
+    }
+  }
+
+  @CaptureSpan()
+  public async updateLastSeen(
+    hostId: ObjectID,
+    extra?: {
+      osType?: string | undefined;
+      osVersion?: string | undefined;
+      agentVersion?: string | undefined;
+    },
+  ): Promise<void> {
+    const cacheKey: string = hostId.toString();
+    const extrasFingerprint: string = crypto
+      .createHash("sha1")
+      .update(
+        JSON.stringify({
+          osType: extra?.osType ?? null,
+          osVersion: extra?.osVersion ?? null,
+          agentVersion: extra?.agentVersion ?? null,
+        }),
+      )
+      .digest("hex");
+
+    const cached: string | null = await GlobalCache.getString(
+      LAST_SEEN_CACHE_NAMESPACE,
+      cacheKey,
+    );
+
+    if (cached === extrasFingerprint) {
+      return; // same data was written recently
+    }
+
+    await GlobalCache.setString(
+      LAST_SEEN_CACHE_NAMESPACE,
+      cacheKey,
+      extrasFingerprint,
+      { expiresInSeconds: LAST_SEEN_THROTTLE_SECONDS },
+    );
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const data: any = {
+      lastSeenAt: OneUptimeDate.getCurrentDate(),
+      otelCollectorStatus: "connected",
+    };
+
+    if (extra?.osType) {
+      data.osType = extra.osType;
+    }
+    if (extra?.osVersion) {
+      data.osVersion = extra.osVersion;
+    }
+    if (extra?.agentVersion) {
+      data.agentVersion = extra.agentVersion;
+    }
+
+    await this.updateOneById({
+      id: hostId,
+      data: data,
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
+  /**
+   * Additively attach labels to a Podman host. Existing labels are
+   * never removed — manual labels set via the UI survive ingest. The
+   * set of labelIds passed in is fingerprinted and cached for 60s so
+   * the common case (steady-state collector pushing the same label
+   * set every batch) costs one in-memory lookup, not a join-table
+   * scan.
+   */
+  @CaptureSpan()
+  public async attachLabels(data: {
+    podmanHostId: ObjectID;
+    labelIds: Array<ObjectID>;
+  }): Promise<void> {
+    if (!data.labelIds || data.labelIds.length === 0) {
+      return;
+    }
+
+    const cacheKey: string = data.podmanHostId.toString();
+    const fingerprint: string = fingerprintLabelIds(data.labelIds);
+    const cached: string | null = await GlobalCache.getString(
+      LABELS_APPLIED_CACHE_NAMESPACE,
+      cacheKey,
+    );
+    if (cached === fingerprint) {
+      return;
+    }
+
+    try {
+      const podmanHostIdStr: string = data.podmanHostId.toString();
+      const existingLabels: Array<Label> = await this.getRepository()
+        .createQueryBuilder()
+        .relation(Model, "labels")
+        .of(podmanHostIdStr)
+        .loadMany();
+
+      const existingIds: Set<string> = new Set();
+      for (const lbl of existingLabels) {
+        const idStr: string | undefined = lbl._id?.toString();
+        if (idStr) {
+          existingIds.add(idStr);
+        }
+      }
+
+      const toAddIds: Array<string> = [];
+      const seen: Set<string> = new Set();
+      for (const id of data.labelIds) {
+        const idStr: string = id.toString();
+        if (existingIds.has(idStr) || seen.has(idStr)) {
+          continue;
+        }
+        seen.add(idStr);
+        toAddIds.push(idStr);
+      }
+
+      if (toAddIds.length > 0) {
+        await this.getRepository()
+          .createQueryBuilder()
+          .relation(Model, "labels")
+          .of(podmanHostIdStr)
+          .add(toAddIds);
+      }
+
+      await GlobalCache.setString(
+        LABELS_APPLIED_CACHE_NAMESPACE,
+        cacheKey,
+        fingerprint,
+        { expiresInSeconds: LABELS_APPLIED_CACHE_TTL_SECONDS },
+      );
+    } catch (err) {
+      logger.warn(
+        `PodmanHostService.attachLabels failed for podman host ${data.podmanHostId.toString()}: ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      );
+    }
+  }
+
+  @CaptureSpan()
+  public async markDisconnectedHosts(): Promise<void> {
+    /*
+     * Threshold must stay well above the 5-minute OTel ingest
+     * maintenance fence (MAINTENANCE_FENCE_TTL_SECONDS in
+     * OtelIngestBaseService) — lastSeenAt is legitimately up to
+     * ~5 minutes stale during continuous telemetry, so a threshold
+     * equal to the fence TTL flaps healthy resources. 15 minutes
+     * gives 3x headroom.
+     */
+    const fifteenMinutesAgo: Date = OneUptimeDate.addRemoveMinutes(
+      OneUptimeDate.getCurrentDate(),
+      -15,
+    );
+
+    const connectedHosts: Array<Model> = await this.findBy({
+      query: {
+        otelCollectorStatus: "connected",
+        lastSeenAt: QueryHelper.lessThan(fifteenMinutesAgo),
+      },
+      select: {
+        _id: true,
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    for (const host of connectedHosts) {
+      if (host._id) {
+        await this.updateOneById({
+          id: new ObjectID(host._id.toString()),
+          data: {
+            otelCollectorStatus: "disconnected",
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+      }
+    }
+  }
+}
+
+function fingerprintLabelIds(labelIds: Array<ObjectID>): string {
+  const sorted: Array<string> = labelIds
+    .map((id: ObjectID) => {
+      return id.toString();
+    })
+    .sort();
+  return crypto.createHash("sha1").update(sorted.join(",")).digest("hex");
+}
+
+export default new Service();