@oneuptime/common 13.0.0 → 13.0.1

package/build/dist/Server/Services/VMwareVCenterOwnerUserService.js

@@ -0,0 +1,122 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/VMwareVCenterOwnerUser";
+import VMwareVCenterFeedService from "./VMwareVCenterFeedService";
+import { VMwareVCenterFeedEventType } from "../../Models/DatabaseModels/VMwareVCenterFeed";
+import { Gray500, Red500 } from "../../Types/BrandColors";
+import UserService from "./UserService";
+import VMwareVCenterService from "./VMwareVCenterService";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+export class Service extends DatabaseService {
+    constructor() {
+        super(Model);
+    }
+    async onBeforeDelete(deleteBy) {
+        /*
+         * The rows are gone by the time onDeleteSuccess runs, so the feed item has
+         * to be built from what was read here.
+         */
+        const itemsToDelete = await this.findBy({
+            query: deleteBy.query,
+            limit: deleteBy.limit,
+            skip: deleteBy.skip,
+            props: {
+                isRoot: true,
+            },
+            select: {
+                vmwareVCenterId: true,
+                projectId: true,
+                userId: true,
+            },
+        });
+        return {
+            carryForward: {
+                itemsToDelete: itemsToDelete,
+            },
+            deleteBy: deleteBy,
+        };
+    }
+    async onDeleteSuccess(onDelete, _itemIdsBeforeDelete) {
+        var _a, _b;
+        const deletedByUserId = ((_a = onDelete.deleteBy.deletedByUser) === null || _a === void 0 ? void 0 : _a.id) || onDelete.deleteBy.props.userId;
+        const itemsToDelete = onDelete.carryForward.itemsToDelete;
+        for (const item of itemsToDelete) {
+            const vmwareVCenterId = item.vmwareVCenterId;
+            const projectId = item.projectId;
+            const userId = item.userId;
+            if (!vmwareVCenterId || !projectId || !userId) {
+                continue;
+            }
+            const user = await UserService.findOneById({
+                id: userId,
+                select: {
+                    name: true,
+                    email: true,
+                },
+                props: {
+                    isRoot: true,
+                },
+            });
+            if (!user || !user.name) {
+                continue;
+            }
+            await VMwareVCenterFeedService.createVMwareVCenterFeedItem({
+                vmwareVCenterId: vmwareVCenterId,
+                projectId: projectId,
+                vmwareVCenterFeedEventType: VMwareVCenterFeedEventType.OwnerUserRemoved,
+                displayColor: Red500,
+                feedInfoInMarkdown: `👨🏻‍💻 Removed **${user.name.toString()}** (${(_b = user.email) === null || _b === void 0 ? void 0 : _b.toString()}) as an owner of ${await VMwareVCenterService.getVMwareVCenterMarkdownLink(projectId, vmwareVCenterId)}.`,
+                userId: deletedByUserId || undefined,
+            });
+        }
+        return onDelete;
+    }
+    async onCreateSuccess(onCreate, createdItem) {
+        const vmwareVCenterId = createdItem.vmwareVCenterId;
+        const projectId = createdItem.projectId;
+        const userId = createdItem.userId;
+        const createdByUserId = createdItem.createdByUserId || onCreate.createBy.props.userId;
+        if (vmwareVCenterId && userId && projectId) {
+            await VMwareVCenterFeedService.createVMwareVCenterFeedItem({
+                vmwareVCenterId: vmwareVCenterId,
+                projectId: projectId,
+                vmwareVCenterFeedEventType: VMwareVCenterFeedEventType.OwnerUserAdded,
+                displayColor: Gray500,
+                feedInfoInMarkdown: `👨🏻‍💻 Added **${await UserService.getUserMarkdownString({
+                    userId: userId,
+                    projectId: projectId,
+                })}** as an owner of ${await VMwareVCenterService.getVMwareVCenterMarkdownLink(projectId, vmwareVCenterId)}.`,
+                userId: createdByUserId || undefined,
+            });
+        }
+        return createdItem;
+    }
+}
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "onBeforeDelete", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Array]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "onDeleteSuccess", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Model]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "onCreateSuccess", null);
+export default new Service();
+//# sourceMappingURL=VMwareVCenterOwnerUserService.js.map

package/build/dist/Server/Services/VMwareVCenterOwnerUserService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"VMwareVCenterOwnerUserService.js","sourceRoot":"","sources":["../../../../Server/Services/VMwareVCenterOwnerUserService.ts"],"names":[],"mappings":"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"}

package/build/dist/Server/Services/VMwareVCenterService.js

@@ -0,0 +1,533 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import DatabaseService from "./DatabaseService";
+import VMwareVCenterLabelRuleEngineService from "./VMwareVCenterLabelRuleEngineService";
+import VMwareVCenterOwnerRuleEngineService from "./VMwareVCenterOwnerRuleEngineService";
+import Model from "../../Models/DatabaseModels/VMwareVCenter";
+import VMwareVCenterFeedService from "./VMwareVCenterFeedService";
+import { VMwareVCenterFeedEventType } from "../../Models/DatabaseModels/VMwareVCenterFeed";
+import ResourceFeedUtil from "../Utils/ResourceFeed/ResourceFeedUtil";
+import { Blue500, Gray500, Green500, Yellow500 } from "../../Types/BrandColors";
+import URL from "../../Types/API/URL";
+import DatabaseConfig from "../DatabaseConfig";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import ResourceHeartbeat from "../Utils/Telemetry/ResourceHeartbeat";
+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 from "../Utils/Logger";
+import crypto from "crypto";
+const LAST_SEEN_CACHE_NAMESPACE = "vmware-vcenter-last-seen";
+const LAST_SEEN_THROTTLE_SECONDS = 60;
+const LABELS_APPLIED_CACHE_NAMESPACE = "vmware-vcenter-labels-applied";
+const LABELS_APPLIED_CACHE_TTL_SECONDS = 60;
+export class Service extends DatabaseService {
+    constructor() {
+        super(Model);
+    }
+    async onCreateSuccess(onCreate, createdItem) {
+        /*
+         * Rules run once, on creation only — exact parity with
+         * KubernetesClusterService. Label engine first: it syncs the
+         * in-memory labels so the owner engine can match rule-added labels.
+         */
+        if (createdItem.projectId && createdItem.id) {
+            Promise.resolve()
+                .then(async () => {
+                await VMwareVCenterLabelRuleEngineService.applyRulesToVMwareVCenter(createdItem);
+            })
+                .then(async () => {
+                await VMwareVCenterOwnerRuleEngineService.applyRulesToVMwareVCenter(createdItem);
+            })
+                .catch((error) => {
+                var _a, _b;
+                logger.error(`Error applying vCenter rules in VMwareVCenterService.onCreateSuccess: ${error}`, {
+                    projectId: (_a = createdItem.projectId) === null || _a === void 0 ? void 0 : _a.toString(),
+                    vmwareVCenterId: (_b = createdItem.id) === null || _b === void 0 ? void 0 : _b.toString(),
+                });
+            });
+        }
+        /*
+         * The overview page can say what this vCenter looks like now; only the
+         * feed can say why it exists at all - whether a person added it or
+         * ingest registered it the first time telemetry named it. Fire and
+         * forget: a feed write must never fail the create it describes.
+         */
+        this.writeVMwareVCenterCreatedFeed(createdItem, onCreate).catch((error) => {
+            logger.error(error);
+        });
+        return createdItem;
+    }
+    async findOrCreateByName(data) {
+        /*
+         * A vCenter is keyed by the `vmware.vcenter.name` OTel resource
+         * attribute, which the user configures on the VMware Agent
+         * (VMWARE_VCENTER_NAME). Look it up case-insensitively: the unique
+         * guard (checkUniqueColumnBy -> findWithSameText) compares
+         * case-insensitively, so a case-sensitive lookup would miss an existing
+         * row that differs only by case, then fail to create it — wedging
+         * ingest for that vCenter. Unlike DockerHost.hostIdentifier (host.name
+         * casing is unstable on Windows) the configured vCenter name's casing
+         * is stable, so we preserve the user's casing on create instead of
+         * canonicalizing to lowercase.
+         */
+        const name = data.name.trim();
+        const existingVCenter = await this.findOneBy({
+            query: {
+                projectId: data.projectId,
+                name: QueryHelper.findWithSameText(name),
+            },
+            select: {
+                _id: true,
+                projectId: true,
+                name: true,
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+        if (existingVCenter) {
+            return existingVCenter;
+        }
+        try {
+            // Create new vCenter
+            const newVCenter = new Model();
+            newVCenter.projectId = data.projectId;
+            newVCenter.name = name;
+            newVCenter.otelCollectorStatus = "connected";
+            newVCenter.lastSeenAt = OneUptimeDate.getCurrentDate();
+            const createdVCenter = await this.create({
+                data: newVCenter,
+                props: {
+                    isRoot: true,
+                },
+            });
+            return createdVCenter;
+        }
+        catch (_a) {
+            /*
+             * Either two ingest workers raced to create the same vCenter, or a
+             * vCenter with this name 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 reFetchedVCenter = await this.findOneBy({
+                query: {
+                    projectId: data.projectId,
+                    name: QueryHelper.findWithSameText(name),
+                },
+                select: {
+                    _id: true,
+                    projectId: true,
+                    name: true,
+                },
+                props: {
+                    isRoot: true,
+                },
+            });
+            if (reFetchedVCenter) {
+                return reFetchedVCenter;
+            }
+            throw new Error("Failed to create or find vCenter: " + name);
+        }
+    }
+    /*
+     * Refresh lastSeenAt / connection status and (optionally) the
+     * snapshot columns the list page renders. Count columns ride this
+     * extras path with COALESCE-per-column semantics: a key that is
+     * undefined is simply not written, so a partial batch (one that
+     * carried no resource of that kind) never zeroes a count. The
+     * 60-second extras fingerprint cache is the write throttle — the
+     * steady state (identical snapshot every collection) costs one Redis
+     * read per batch and at most one Postgres UPDATE per minute.
+     *
+     * Two callers share this throttle with DISJOINT extras shapes: the
+     * metrics snapshot flush (inventory counts + datastore capacity, every
+     * batch) and the fenced autoDiscoverVMwareVCenter maintenance path
+     * (agentVersion only — and usually an all-null fingerprint, since the
+     * shipped agent config does not stamp oneuptime.agent.version). The
+     * single fingerprint covers the whole extras object, so each alternation
+     * between the two shapes busts the throttle: at most one extra Postgres
+     * UPDATE per maintenance-fence window (~5 min), which is accepted. Do
+     * NOT key the cache per-caller — that would let two callers each refresh
+     * lastSeenAt under their own throttle and is not worth the complexity
+     * for one UPDATE per 5 minutes.
+     */
+    async updateLastSeen(vcenterId, extra) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        const extrasFingerprint = crypto
+            .createHash("sha1")
+            .update(JSON.stringify({
+            agentVersion: (_a = extra === null || extra === void 0 ? void 0 : extra.agentVersion) !== null && _a !== void 0 ? _a : null,
+            datacenterCount: (_b = extra === null || extra === void 0 ? void 0 : extra.datacenterCount) !== null && _b !== void 0 ? _b : null,
+            clusterCount: (_c = extra === null || extra === void 0 ? void 0 : extra.clusterCount) !== null && _c !== void 0 ? _c : null,
+            hostCount: (_d = extra === null || extra === void 0 ? void 0 : extra.hostCount) !== null && _d !== void 0 ? _d : null,
+            vmCount: (_e = extra === null || extra === void 0 ? void 0 : extra.vmCount) !== null && _e !== void 0 ? _e : null,
+            poweredOnVmCount: (_f = extra === null || extra === void 0 ? void 0 : extra.poweredOnVmCount) !== null && _f !== void 0 ? _f : null,
+            datastoreCount: (_g = extra === null || extra === void 0 ? void 0 : extra.datastoreCount) !== null && _g !== void 0 ? _g : null,
+            resourcePoolCount: (_h = extra === null || extra === void 0 ? void 0 : extra.resourcePoolCount) !== null && _h !== void 0 ? _h : null,
+            datastoreCapacityBytes: (_j = extra === null || extra === void 0 ? void 0 : extra.datastoreCapacityBytes) !== null && _j !== void 0 ? _j : null,
+            datastoreUsedBytes: (_k = extra === null || extra === void 0 ? void 0 : extra.datastoreUsedBytes) !== null && _k !== void 0 ? _k : null,
+        }))
+            .digest("hex");
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const liveness = {
+            lastSeenAt: OneUptimeDate.getCurrentDate(),
+            otelCollectorStatus: "connected",
+        };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const metadata = {};
+        if (extra === null || extra === void 0 ? void 0 : extra.agentVersion) {
+            metadata.agentVersion = extra.agentVersion;
+        }
+        /*
+         * Counts and byte totals: 0 is a legitimate value (an empty datacenter,
+         * every VM powered off) — gate on undefined, not falsiness.
+         */
+        if ((extra === null || extra === void 0 ? void 0 : extra.datacenterCount) !== undefined) {
+            metadata.datacenterCount = extra.datacenterCount;
+        }
+        if ((extra === null || extra === void 0 ? void 0 : extra.clusterCount) !== undefined) {
+            metadata.clusterCount = extra.clusterCount;
+        }
+        if ((extra === null || extra === void 0 ? void 0 : extra.hostCount) !== undefined) {
+            metadata.hostCount = extra.hostCount;
+        }
+        if ((extra === null || extra === void 0 ? void 0 : extra.vmCount) !== undefined) {
+            metadata.vmCount = extra.vmCount;
+        }
+        if ((extra === null || extra === void 0 ? void 0 : extra.poweredOnVmCount) !== undefined) {
+            metadata.poweredOnVmCount = extra.poweredOnVmCount;
+        }
+        if ((extra === null || extra === void 0 ? void 0 : extra.datastoreCount) !== undefined) {
+            metadata.datastoreCount = extra.datastoreCount;
+        }
+        if ((extra === null || extra === void 0 ? void 0 : extra.resourcePoolCount) !== undefined) {
+            metadata.resourcePoolCount = extra.resourcePoolCount;
+        }
+        if ((extra === null || extra === void 0 ? void 0 : extra.datastoreCapacityBytes) !== undefined) {
+            metadata.datastoreCapacityBytes = extra.datastoreCapacityBytes;
+        }
+        if ((extra === null || extra === void 0 ? void 0 : extra.datastoreUsedBytes) !== undefined) {
+            metadata.datastoreUsedBytes = extra.datastoreUsedBytes;
+        }
+        /*
+         * One gated, non-blocking heartbeat write. The gates, the fail-open /
+         * fail-closed split and the liveness-only fallback all live in
+         * ResourceHeartbeat — see there for why this row's throttle used to
+         * provide no throttling at all.
+         */
+        await ResourceHeartbeat.write({
+            service: this,
+            id: vcenterId,
+            cacheNamespace: LAST_SEEN_CACHE_NAMESPACE,
+            throttleInSeconds: LAST_SEEN_THROTTLE_SECONDS,
+            liveness: liveness,
+            metadata: metadata,
+            fingerprint: extrasFingerprint,
+            describe: `vcenter ${vcenterId.toString()}`,
+        });
+    }
+    /**
+     * Additively attach labels to a vCenter. 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.
+     */
+    async attachLabels(data) {
+        var _a;
+        if (!data.labelIds || data.labelIds.length === 0) {
+            return;
+        }
+        const cacheKey = data.vmwareVCenterId.toString();
+        const fingerprint = fingerprintLabelIds(data.labelIds);
+        const cached = await GlobalCache.getString(LABELS_APPLIED_CACHE_NAMESPACE, cacheKey);
+        if (cached === fingerprint) {
+            return;
+        }
+        try {
+            const vmwareVCenterIdStr = data.vmwareVCenterId.toString();
+            const existingLabels = await this.getRepository()
+                .createQueryBuilder()
+                .relation(Model, "labels")
+                .of(vmwareVCenterIdStr)
+                .loadMany();
+            const existingIds = new Set();
+            for (const lbl of existingLabels) {
+                const idStr = (_a = lbl._id) === null || _a === void 0 ? void 0 : _a.toString();
+                if (idStr) {
+                    existingIds.add(idStr);
+                }
+            }
+            const toAddIds = [];
+            const seen = new Set();
+            for (const id of data.labelIds) {
+                const idStr = 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(vmwareVCenterIdStr)
+                    .add(toAddIds);
+            }
+            await GlobalCache.setString(LABELS_APPLIED_CACHE_NAMESPACE, cacheKey, fingerprint, { expiresInSeconds: LABELS_APPLIED_CACHE_TTL_SECONDS });
+        }
+        catch (err) {
+            logger.warn(`VMwareVCenterService.attachLabels failed for vCenter ${data.vmwareVCenterId.toString()}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    async markDisconnectedVCenters() {
+        /*
+         * 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, and is also well above the receiver's default
+         * 2-minute collection interval.
+         */
+        const fifteenMinutesAgo = OneUptimeDate.addRemoveMinutes(OneUptimeDate.getCurrentDate(), -15);
+        const connectedVCenters = await this.findBy({
+            query: {
+                otelCollectorStatus: "connected",
+                lastSeenAt: QueryHelper.lessThan(fifteenMinutesAgo),
+            },
+            select: {
+                _id: true,
+            },
+            limit: LIMIT_MAX,
+            skip: 0,
+            props: {
+                isRoot: true,
+            },
+        });
+        for (const vcenter of connectedVCenters) {
+            if (vcenter._id) {
+                await this.updateOneById({
+                    id: new ObjectID(vcenter._id.toString()),
+                    data: {
+                        otelCollectorStatus: "disconnected",
+                    },
+                    props: {
+                        isRoot: true,
+                    },
+                });
+            }
+        }
+    }
+    /**
+     * Display name for this vCenter, or an empty string when the row is gone.
+     * Feed writers call this on a best-effort basis, so a missing row must not
+     * throw and take the surrounding write down with it.
+     */
+    async getVMwareVCenterName(data) {
+        const vmwareVCenter = await this.findOneById({
+            id: data.vmwareVCenterId,
+            select: {
+                name: true,
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+        return (vmwareVCenter === null || vmwareVCenter === void 0 ? void 0 : vmwareVCenter.name) || "";
+    }
+    async getVMwareVCenterLinkInDashboard(projectId, vmwareVCenterId) {
+        const dashboardUrl = await DatabaseConfig.getDashboardUrl();
+        return URL.fromString(dashboardUrl.toString()).addRoute(`/${projectId.toString()}/vmware/${vmwareVCenterId.toString()}`);
+    }
+    /**
+     * "[vCenter vcsa-prod](https://…)" - the form every feed item uses to
+     * name the resource it is about.
+     */
+    async getVMwareVCenterMarkdownLink(projectId, vmwareVCenterId) {
+        const name = await this.getVMwareVCenterName({
+            vmwareVCenterId: vmwareVCenterId,
+        });
+        const link = await this.getVMwareVCenterLinkInDashboard(projectId, vmwareVCenterId);
+        return `[vCenter ${name}](${link.toString()})`;
+    }
+    async writeVMwareVCenterCreatedFeed(createdItem, onCreate) {
+        const projectId = createdItem.projectId;
+        const vmwareVCenterId = createdItem.id || undefined;
+        if (!projectId || !vmwareVCenterId) {
+            return;
+        }
+        /*
+         * Ingest creates these rows with root props and no acting user; every
+         * dashboard, API and Terraform create carries one. That is the whole
+         * signal for "was this discovered automatically or added by a person".
+         */
+        const createdByUserId = createdItem.createdByUserId ||
+            onCreate.createBy.props.userId ||
+            undefined;
+        const markdown = await ResourceFeedUtil.getCreatedFeedMarkdown({
+            resourceTypeName: "vCenter",
+            resourceMarkdownLink: await this.getVMwareVCenterMarkdownLink(projectId, vmwareVCenterId),
+            projectId: projectId,
+            createdByUserId: createdByUserId,
+            description: createdItem.description,
+        });
+        await VMwareVCenterFeedService.createVMwareVCenterFeedItem({
+            vmwareVCenterId: vmwareVCenterId,
+            projectId: projectId,
+            vmwareVCenterFeedEventType: VMwareVCenterFeedEventType.VMwareVCenterCreated,
+            displayColor: Green500,
+            feedInfoInMarkdown: markdown.feedInfoInMarkdown,
+            moreInformationInMarkdown: markdown.moreInformationInMarkdown,
+            userId: createdByUserId,
+        });
+    }
+    async onUpdateSuccess(onUpdate, updatedItemIds) {
+        this.writeVMwareVCenterUpdatedFeed(onUpdate, updatedItemIds).catch((error) => {
+            logger.error(error);
+        });
+        return onUpdate;
+    }
+    async writeVMwareVCenterUpdatedFeed(onUpdate, updatedItemIds) {
+        const updateData = onUpdate.updateBy
+            .data;
+        /*
+         * Heartbeats update lastSeenAt / otelCollectorStatus / agentVersion and the
+         * rollup counters constantly. Only the columns a person would recognise as
+         * a change earn a feed item - see MEANINGFUL_UPDATE_COLUMNS.
+         */
+        const changedColumns = ResourceFeedUtil.getUpdatedColumnsWorthRecording(updateData);
+        if (changedColumns.length === 0 || updatedItemIds.length === 0) {
+            return;
+        }
+        const isArchiveChange = ResourceFeedUtil.isArchiveChange(updateData);
+        const isArchived = Boolean(updateData["isArchived"]);
+        const otherColumns = changedColumns.filter((column) => {
+            return column !== "isArchived";
+        });
+        const updatedByUserId = onUpdate.updateBy.props.userId || undefined;
+        for (const vmwareVCenterId of updatedItemIds) {
+            const vmwareVCenter = await this.findOneById({
+                id: vmwareVCenterId,
+                select: {
+                    projectId: true,
+                },
+                props: {
+                    isRoot: true,
+                },
+            });
+            const projectId = vmwareVCenter === null || vmwareVCenter === void 0 ? void 0 : vmwareVCenter.projectId;
+            if (!projectId) {
+                continue;
+            }
+            const resourceMarkdownLink = await this.getVMwareVCenterMarkdownLink(projectId, vmwareVCenterId);
+            if (isArchiveChange) {
+                await VMwareVCenterFeedService.createVMwareVCenterFeedItem({
+                    vmwareVCenterId: vmwareVCenterId,
+                    projectId: projectId,
+                    vmwareVCenterFeedEventType: isArchived
+                        ? VMwareVCenterFeedEventType.VMwareVCenterArchived
+                        : VMwareVCenterFeedEventType.VMwareVCenterRestored,
+                    displayColor: isArchived ? Yellow500 : Blue500,
+                    feedInfoInMarkdown: isArchived
+                        ? `🗄️ ${resourceMarkdownLink} was archived.`
+                        : `♻️ ${resourceMarkdownLink} was restored from the archive.`,
+                    userId: updatedByUserId,
+                });
+            }
+            if (otherColumns.length > 0) {
+                const markdown = ResourceFeedUtil.getUpdatedFeedMarkdown({
+                    resourceMarkdownLink: resourceMarkdownLink,
+                    columns: otherColumns,
+                });
+                await VMwareVCenterFeedService.createVMwareVCenterFeedItem({
+                    vmwareVCenterId: vmwareVCenterId,
+                    projectId: projectId,
+                    vmwareVCenterFeedEventType: VMwareVCenterFeedEventType.VMwareVCenterUpdated,
+                    displayColor: Gray500,
+                    feedInfoInMarkdown: markdown.feedInfoInMarkdown,
+                    moreInformationInMarkdown: markdown.moreInformationInMarkdown,
+                    userId: updatedByUserId,
+                });
+            }
+        }
+    }
+}
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Model]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "onCreateSuccess", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "findOrCreateByName", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectID, Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "updateLastSeen", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "attachLabels", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "markDisconnectedVCenters", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "getVMwareVCenterName", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectID,
+        ObjectID]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "getVMwareVCenterLinkInDashboard", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ObjectID,
+        ObjectID]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "getVMwareVCenterMarkdownLink", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Array]),
+    __metadata("design:returntype", Promise)
+], Service.prototype, "onUpdateSuccess", null);
+function fingerprintLabelIds(labelIds) {
+    const sorted = labelIds
+        .map((id) => {
+        return id.toString();
+    })
+        .sort();
+    return crypto.createHash("sha1").update(sorted.join(",")).digest("hex");
+}
+export default new Service();
+//# sourceMappingURL=VMwareVCenterService.js.map