@oneuptime/common 11.0.1 → 11.0.2

package/build/dist/Server/Utils/Telemetry/ProxmoxCephSnapshotScan.js

@@ -0,0 +1,854 @@
+import OneUptimeDate from "../../../Types/Date";
+import logger from "../Logger";
+/*
+ * ------------------------------------------------------------------
+ * Proxmox / Ceph snapshot scan — pure fold & derive helpers
+ * ------------------------------------------------------------------
+ *
+ * Extracted from App/FeatureSet/Telemetry/Services/
+ * OtelMetricsIngestService.ts (WI-21 refactor-for-testability, no
+ * behavior change). The ingest service owns the I/O: it walks the
+ * OTLP payload, calls bufferProxmoxSnapshotMetric /
+ * bufferCephSnapshotMetric per datapoint, and at flush time maps the
+ * folded buffers through computeProxmoxGuestBackedUp /
+ * deriveProxmoxClusterSnapshotExtras / deriveCephClusterSnapshotExtras
+ * before handing the results to ProxmoxResourceService /
+ * CephResourceService / *ClusterService. Everything in this module is
+ * pure (Map/object mutation only — no DB, no network), which is what
+ * makes the snapshot-scan semantics unit-testable:
+ *
+ *   - identity labels fold first-non-null-wins; status/metric fields
+ *     fold newest-observedAt-wins,
+ *   - count columns are only derived when the batch carried the
+ *     matching identity series (never zero a count on a partial
+ *     batch — the COALESCE-per-column contract),
+ *   - non-allow-listed metric names are skipped via the exported
+ *     PVE_/CEPH_SNAPSHOT_METRIC_NAMES sets.
+ */
+/*
+ * Proxmox snapshot metrics — emitted by pve-exporter (prometheus
+ * receiver), identity in the `id` datapoint label (node/pve1,
+ * qemu/100, lxc/101, storage/local) plus the pve.scope / pve.type /
+ * pve.id attributes the agent's transform processor derives from it.
+ * Unlike K8s there is no separate object stream: identity, status AND
+ * the latest-metric mirror all arrive on every scrape, so the same
+ * scan feeds the ProxmoxResource inventory upsert and the
+ * ProxmoxCluster count/version snapshot columns (single source — the
+ * list-page counts and the sidebar badges can never drift).
+ *
+ * pve_cpu_usage_ratio is already a true 0..1 ratio — no allocatable-
+ * denominator cache is needed, unlike K8s cpuCoresToPercent.
+ */
+export const PVE_SNAPSHOT_METRIC_NAMES = new Set([
+    // Identity / status (WI-3 cluster counts derive from these)
+    "pve_up",
+    "pve_node_info",
+    "pve_guest_info",
+    "pve_storage_info",
+    "pve_version_info",
+    "pve_ha_state",
+    "pve_onboot_status",
+    // Latest-metric mirror (WI-6 inventory columns)
+    "pve_uptime_seconds",
+    "pve_cpu_usage_ratio",
+    "pve_memory_usage_bytes",
+    "pve_memory_size_bytes",
+    "pve_disk_usage_bytes",
+    "pve_disk_size_bytes",
+    /*
+     * Backup coverage (WI-24) — cluster-level backup-info collector.
+     * pve_not_backed_up_total = count of guests not covered by ANY
+     * backup job; pve_not_backed_up_info = one series per uncovered
+     * guest, labeled only `id`. "Covered by a job" ≠ "backed up
+     * recently/successfully" — freshness needs the PVE task log or PBS
+     * API (v4 API-agent track).
+     */
+    "pve_not_backed_up_total",
+    "pve_not_backed_up_info",
+]);
+/*
+ * Ceph snapshot metrics — emitted by the ceph-mgr prometheus module
+ * (honor_labels), identity in the `ceph_daemon` (osd.3, mon.a, …) or
+ * `pool_id` datapoint labels. Same single-source rule as Proxmox: one
+ * scan feeds the CephResource inventory and the CephCluster
+ * count/health/capacity snapshot columns.
+ */
+export const CEPH_SNAPSHOT_METRIC_NAMES = new Set([
+    // Cluster-level health / capacity (WI-3 columns)
+    "ceph_health_status",
+    "ceph_cluster_total_bytes",
+    "ceph_cluster_total_used_bytes",
+    // Daemon identity / status
+    "ceph_mon_quorum_status",
+    "ceph_mon_metadata",
+    "ceph_osd_up",
+    "ceph_osd_in",
+    "ceph_osd_metadata",
+    "ceph_mgr_metadata",
+    "ceph_mds_metadata",
+    "ceph_rgw_metadata",
+    // OSD latest-metric mirror (WI-6 inventory columns)
+    "ceph_osd_stat_bytes",
+    "ceph_osd_stat_bytes_used",
+    "ceph_osd_apply_latency_ms",
+    "ceph_osd_commit_latency_ms",
+    "ceph_osd_numpg",
+    // Pool identity + latest-metric mirror
+    "ceph_pool_metadata",
+    "ceph_pool_stored",
+    "ceph_pool_max_avail",
+    "ceph_pool_objects",
+    "ceph_pool_rd",
+    "ceph_pool_wr",
+]);
+/*
+ * Same finite-or-null coercion contract as the ingest service's
+ * toNumberOrNull (NaN / ±Infinity fold to null so a malformed
+ * datapoint is skipped rather than poisoning a snapshot column).
+ */
+function toNumberOrNull(value) {
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? value : null;
+    }
+    if (typeof value === "string") {
+        const parsed = Number.parseFloat(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+/*
+ * Same fall-back-to-now parse contract as the ingest service's
+ * safeParseUnixNano — only the Date is needed on the snapshot path.
+ */
+function parseUnixNanoToDate(value, context) {
+    let numericValue = OneUptimeDate.getCurrentDateAsUnixNano();
+    if (value !== undefined && value !== null) {
+        try {
+            if (typeof value === "string") {
+                const parsed = Number.parseFloat(value);
+                if (isNaN(parsed)) {
+                    throw new Error(`Invalid timestamp string: ${value}`);
+                }
+                numericValue = parsed;
+            }
+            else if (typeof value === "number") {
+                if (!Number.isFinite(value)) {
+                    throw new Error(`Invalid timestamp number: ${value}`);
+                }
+                numericValue = value;
+            }
+        }
+        catch (error) {
+            logger.warn(`Error processing ${context}: ${error instanceof Error ? error.message : String(error)}, using current time`);
+            numericValue = OneUptimeDate.getCurrentDateAsUnixNano();
+        }
+    }
+    return OneUptimeDate.fromUnixNano(numericValue);
+}
+// Same trim-or-null read contract as OtelIngestBaseService.getStringAttribute.
+function getStringAttribute(attributes, key) {
+    for (const attribute of attributes) {
+        if (attribute["key"] === key &&
+            attribute["value"] &&
+            attribute["value"]["stringValue"]) {
+            const value = attribute["value"]["stringValue"];
+            if (typeof value === "string" && value.trim()) {
+                return value.trim();
+            }
+        }
+    }
+    return null;
+}
+export function getOrCreateProxmoxClusterSnapshot(buffer, clusterIdStr) {
+    let entry = buffer.get(clusterIdStr);
+    if (!entry) {
+        entry = {
+            sawNodeIdentity: false,
+            sawNodeUp: false,
+            sawGuestIdentity: false,
+            sawStorageIdentity: false,
+            pveVersion: null,
+            sawBackupInfo: false,
+            guestsWithoutBackupCount: null,
+            notBackedUpIds: new Set(),
+        };
+        buffer.set(clusterIdStr, entry);
+    }
+    return entry;
+}
+/*
+ * Fold one pve_* datapoint into the per-cluster buffers. Identity
+ * lives in the `id` DATAPOINT label (prometheus receiver), so this
+ * reads the raw datapoint attribute array — not the merged
+ * resource-prefixed map the K8s scan uses.
+ */
+export function bufferProxmoxSnapshotMetric(data) {
+    const valueFromInt = toNumberOrNull(data.datapoint["asInt"]);
+    const valueFromDouble = toNumberOrNull(data.datapoint["asDouble"]);
+    const rawValue = valueFromDouble !== null && valueFromDouble !== void 0 ? valueFromDouble : valueFromInt;
+    if (rawValue === null) {
+        return;
+    }
+    const observedAt = parseUnixNanoToDate(data.datapoint["timeUnixNano"], "pve snapshot timeUnixNano");
+    const dpAttributes = data.datapoint["attributes"] || [];
+    const cluster = getOrCreateProxmoxClusterSnapshot(data.clusterBuffer, data.clusterIdStr);
+    /*
+     * pve_version_info carries no `id` label — it is the cluster-level
+     * PVE version (this is what populates ProxmoxCluster.pveVersion).
+     */
+    if (data.metricName === "pve_version_info") {
+        const version = getStringAttribute(dpAttributes, "version");
+        if (version) {
+            cluster.pveVersion = version;
+        }
+        return;
+    }
+    /*
+     * WI-24 backup coverage — cluster-level backup-info collector
+     * series, handled before the generic scope parse:
+     * pve_not_backed_up_total carries no `id` label, and the
+     * pve_not_backed_up_info `id` label format is unverified upstream
+     * (`qemu/100` vs bare vmid — §3.9 spike), so neither goes through
+     * the inventory-row path. The ids are folded into the cluster
+     * buffer and joined to the buffered Guest rows at flush time.
+     */
+    if (data.metricName === "pve_not_backed_up_total") {
+        cluster.sawBackupInfo = true;
+        cluster.guestsWithoutBackupCount = Math.max(0, Math.trunc(rawValue));
+        return;
+    }
+    if (data.metricName === "pve_not_backed_up_info") {
+        cluster.sawBackupInfo = true;
+        const uncoveredId = getStringAttribute(dpAttributes, "id");
+        if (uncoveredId) {
+            cluster.notBackedUpIds.add(uncoveredId);
+        }
+        return;
+    }
+    const id = getStringAttribute(dpAttributes, "id");
+    if (!id) {
+        return;
+    }
+    /*
+     * Scope/type: prefer the pve.scope / pve.type attributes stamped
+     * by the agent's transform/pve-identity processor; fall back to
+     * parsing the id prefix so inventory still populates on a
+     * hand-rolled collector config without the transform.
+     */
+    const slashIndex = id.indexOf("/");
+    const idPrefix = slashIndex > 0 ? id.substring(0, slashIndex) : "";
+    const pveType = getStringAttribute(dpAttributes, "pve.type") || idPrefix;
+    let scope = getStringAttribute(dpAttributes, "pve.scope");
+    if (!scope) {
+        scope = idPrefix === "qemu" || idPrefix === "lxc" ? "guest" : idPrefix;
+    }
+    let kind;
+    if (scope === "node") {
+        kind = "Node";
+    }
+    else if (scope === "guest") {
+        kind = "Guest";
+    }
+    else if (scope === "storage") {
+        kind = "Storage";
+    }
+    else {
+        // cluster/* series and unknown scopes aren't inventory rows.
+        return;
+    }
+    const patch = {
+        kind,
+        externalId: id,
+        name: null,
+        vmid: null,
+        guestType: null,
+        parentNodeName: null,
+        isUp: null,
+        haState: null,
+        onboot: null,
+        uptimeSeconds: null,
+        latestCpuPercent: null,
+        latestMemoryBytes: null,
+        maxMemoryBytes: null,
+        latestDiskBytes: null,
+        maxDiskBytes: null,
+        observedAt,
+    };
+    if (kind === "Guest") {
+        patch.guestType = pveType === "qemu" || pveType === "lxc" ? pveType : null;
+        if (slashIndex > 0) {
+            const vmidParsed = parseInt(id.substring(slashIndex + 1), 10);
+            patch.vmid = isNaN(vmidParsed) ? null : vmidParsed;
+        }
+    }
+    // `node` label: present on the info series and pve_onboot_status.
+    const nodeLabel = getStringAttribute(dpAttributes, "node");
+    if (nodeLabel && kind !== "Node") {
+        patch.parentNodeName = nodeLabel;
+    }
+    switch (data.metricName) {
+        case "pve_up": {
+            patch.isUp = rawValue >= 1;
+            if (kind === "Node") {
+                // pve_up doubles as the node-identity fallback per the spec.
+                cluster.sawNodeIdentity = true;
+                cluster.sawNodeUp = true;
+            }
+            break;
+        }
+        case "pve_node_info": {
+            patch.name = getStringAttribute(dpAttributes, "name");
+            cluster.sawNodeIdentity = true;
+            break;
+        }
+        case "pve_guest_info": {
+            patch.name = getStringAttribute(dpAttributes, "name");
+            cluster.sawGuestIdentity = true;
+            break;
+        }
+        case "pve_storage_info": {
+            patch.name = getStringAttribute(dpAttributes, "storage");
+            cluster.sawStorageIdentity = true;
+            break;
+        }
+        case "pve_ha_state": {
+            /*
+             * Enum-series: one row per possible state, value 1 marks the
+             * current one. Only the active row carries signal — skip the
+             * zero-valued rows entirely so they don't create empty patches.
+             */
+            if (rawValue < 1) {
+                return;
+            }
+            patch.haState = getStringAttribute(dpAttributes, "state");
+            break;
+        }
+        case "pve_onboot_status": {
+            patch.onboot = rawValue >= 1;
+            break;
+        }
+        case "pve_uptime_seconds": {
+            patch.uptimeSeconds = Math.max(0, Math.trunc(rawValue));
+            break;
+        }
+        case "pve_cpu_usage_ratio": {
+            /*
+             * Already a true 0..1 ratio — no allocatable-denominator cache
+             * needed, unlike K8s cpuCoresToPercent.
+             */
+            patch.latestCpuPercent = rawValue * 100;
+            break;
+        }
+        case "pve_memory_usage_bytes": {
+            patch.latestMemoryBytes = Math.max(0, Math.trunc(rawValue));
+            break;
+        }
+        case "pve_memory_size_bytes": {
+            patch.maxMemoryBytes = Math.max(0, Math.trunc(rawValue));
+            break;
+        }
+        case "pve_disk_usage_bytes": {
+            patch.latestDiskBytes = Math.max(0, Math.trunc(rawValue));
+            break;
+        }
+        case "pve_disk_size_bytes": {
+            patch.maxDiskBytes = Math.max(0, Math.trunc(rawValue));
+            break;
+        }
+        default: {
+            return;
+        }
+    }
+    foldProxmoxResourceSnapshot({
+        buffer: data.resourceBuffer,
+        clusterIdStr: data.clusterIdStr,
+        patch,
+    });
+}
+/*
+ * Merge a patch into the per-cluster Proxmox buffer: identity labels
+ * are first-non-null-wins (stable, and a batch missing an info
+ * series must not blank them), status/metric fields are
+ * newest-observedAt-wins (K8s buffer semantics).
+ */
+export function foldProxmoxResourceSnapshot(data) {
+    let perCluster = data.buffer.get(data.clusterIdStr);
+    if (!perCluster) {
+        perCluster = new Map();
+        data.buffer.set(data.clusterIdStr, perCluster);
+    }
+    const key = `${data.patch.kind}|${data.patch.externalId}`;
+    const existing = perCluster.get(key);
+    if (!existing) {
+        perCluster.set(key, data.patch);
+        return;
+    }
+    const patch = data.patch;
+    const newer = patch.observedAt >= existing.observedAt;
+    // Identity: first-non-null wins.
+    if (existing.name === null && patch.name !== null) {
+        existing.name = patch.name;
+    }
+    if (existing.vmid === null && patch.vmid !== null) {
+        existing.vmid = patch.vmid;
+    }
+    if (existing.guestType === null && patch.guestType !== null) {
+        existing.guestType = patch.guestType;
+    }
+    if (existing.parentNodeName === null && patch.parentNodeName !== null) {
+        existing.parentNodeName = patch.parentNodeName;
+    }
+    // Status / metrics: newest observation wins.
+    if (patch.isUp !== null && newer) {
+        existing.isUp = patch.isUp;
+    }
+    if (patch.haState !== null && newer) {
+        existing.haState = patch.haState;
+    }
+    if (patch.onboot !== null && newer) {
+        existing.onboot = patch.onboot;
+    }
+    if (patch.uptimeSeconds !== null && newer) {
+        existing.uptimeSeconds = patch.uptimeSeconds;
+    }
+    if (patch.latestCpuPercent !== null && newer) {
+        existing.latestCpuPercent = patch.latestCpuPercent;
+    }
+    if (patch.latestMemoryBytes !== null && newer) {
+        existing.latestMemoryBytes = patch.latestMemoryBytes;
+    }
+    if (patch.maxMemoryBytes !== null && newer) {
+        existing.maxMemoryBytes = patch.maxMemoryBytes;
+    }
+    if (patch.latestDiskBytes !== null && newer) {
+        existing.latestDiskBytes = patch.latestDiskBytes;
+    }
+    if (patch.maxDiskBytes !== null && newer) {
+        existing.maxDiskBytes = patch.maxDiskBytes;
+    }
+    if (patch.observedAt > existing.observedAt) {
+        existing.observedAt = patch.observedAt;
+    }
+}
+/*
+ * WI-24: a guest is "covered by a backup job" exactly when the batch
+ * carried the backup-info collector output at all AND no
+ * pve_not_backed_up_info series carries its id (series present =
+ * NOT covered — the exporter emits one info row per uncovered
+ * guest). A batch without the collector output yields null, so the
+ * upsert COALESCE keeps the last-known value (the same
+ * never-zero-on-partial-batch guard the count columns use).
+ *
+ * The info `id` label's value format is unverified upstream
+ * (`qemu/100` vs bare vmid — §3.9 spike), so match both the full
+ * externalId and the bare vmid.
+ */
+export function computeProxmoxGuestBackedUp(entry, snap) {
+    if (entry.kind !== "Guest" || !(snap === null || snap === void 0 ? void 0 : snap.sawBackupInfo)) {
+        return null;
+    }
+    if (snap.notBackedUpIds.has(entry.externalId)) {
+        return false;
+    }
+    if (entry.vmid !== null && snap.notBackedUpIds.has(String(entry.vmid))) {
+        return false;
+    }
+    return true;
+}
+/*
+ * Derive the ProxmoxCluster snapshot columns from one folded batch.
+ * Counts are only set when the batch carried the matching identity
+ * series — never zero a count on a partial batch. Returns an object
+ * whose keys are exactly the columns to write (empty object = nothing
+ * to write).
+ */
+export function deriveProxmoxClusterSnapshotExtras(entries, snap) {
+    const extras = {};
+    if (snap === null || snap === void 0 ? void 0 : snap.pveVersion) {
+        extras.pveVersion = snap.pveVersion;
+    }
+    if (snap === null || snap === void 0 ? void 0 : snap.sawNodeIdentity) {
+        extras.nodeCount = entries.filter((e) => {
+            return e.kind === "Node";
+        }).length;
+    }
+    if (snap === null || snap === void 0 ? void 0 : snap.sawNodeUp) {
+        extras.onlineNodeCount = entries.filter((e) => {
+            return e.kind === "Node" && e.isUp === true;
+        }).length;
+    }
+    if (snap === null || snap === void 0 ? void 0 : snap.sawGuestIdentity) {
+        extras.guestCount = entries.filter((e) => {
+            return e.kind === "Guest";
+        }).length;
+    }
+    if (snap === null || snap === void 0 ? void 0 : snap.sawStorageIdentity) {
+        extras.storageCount = entries.filter((e) => {
+            return e.kind === "Storage";
+        }).length;
+    }
+    /*
+     * WI-24: written only when the batch carried pve_not_backed_up_total
+     * itself — NULL in Postgres stays "collector not reporting",
+     * distinct from 0 uncovered guests.
+     */
+    if (snap &&
+        snap.guestsWithoutBackupCount !== null &&
+        snap.guestsWithoutBackupCount !== undefined) {
+        extras.guestsWithoutBackupCount = snap.guestsWithoutBackupCount;
+    }
+    return extras;
+}
+export function getOrCreateCephClusterSnapshot(buffer, clusterIdStr) {
+    let entry = buffer.get(clusterIdStr);
+    if (!entry) {
+        entry = {
+            sawMonMetadata: false,
+            sawOsdMetadata: false,
+            sawOsdUp: false,
+            sawOsdIn: false,
+            sawPoolMetadata: false,
+            healthStatus: null,
+            totalBytes: null,
+            totalUsedBytes: null,
+            cephVersionCounts: new Map(),
+        };
+        buffer.set(clusterIdStr, entry);
+    }
+    return entry;
+}
+export function emptyCephResourceEntry(kind, externalId, observedAt) {
+    return {
+        kind,
+        externalId,
+        name: null,
+        hostname: null,
+        daemonVersion: null,
+        deviceClass: null,
+        isUp: null,
+        isIn: null,
+        inQuorum: null,
+        statBytes: null,
+        statBytesUsed: null,
+        applyLatencyMs: null,
+        commitLatencyMs: null,
+        pgCount: null,
+        storedBytes: null,
+        maxAvailBytes: null,
+        objects: null,
+        readOpsCounter: null,
+        writeOpsCounter: null,
+        observedAt,
+    };
+}
+/*
+ * Fold one ceph_* datapoint into the per-cluster buffers. Pool
+ * series are keyed by the `pool_id` datapoint label, daemon series
+ * by `ceph_daemon` (osd.3, mon.a, mgr.x, …).
+ */
+export function bufferCephSnapshotMetric(data) {
+    const valueFromInt = toNumberOrNull(data.datapoint["asInt"]);
+    const valueFromDouble = toNumberOrNull(data.datapoint["asDouble"]);
+    const rawValue = valueFromDouble !== null && valueFromDouble !== void 0 ? valueFromDouble : valueFromInt;
+    if (rawValue === null) {
+        return;
+    }
+    const observedAt = parseUnixNanoToDate(data.datapoint["timeUnixNano"], "ceph snapshot timeUnixNano");
+    const dpAttributes = data.datapoint["attributes"] || [];
+    const cluster = getOrCreateCephClusterSnapshot(data.clusterBuffer, data.clusterIdStr);
+    // Cluster-level series — no per-resource row.
+    if (data.metricName === "ceph_health_status") {
+        // 0 = HEALTH_OK, 1 = HEALTH_WARN, 2 = HEALTH_ERR.
+        cluster.healthStatus = Math.max(0, Math.trunc(rawValue));
+        return;
+    }
+    if (data.metricName === "ceph_cluster_total_bytes") {
+        cluster.totalBytes = Math.max(0, rawValue);
+        return;
+    }
+    if (data.metricName === "ceph_cluster_total_used_bytes") {
+        cluster.totalUsedBytes = Math.max(0, rawValue);
+        return;
+    }
+    if (data.metricName.startsWith("ceph_pool_")) {
+        const poolId = getStringAttribute(dpAttributes, "pool_id");
+        if (!poolId) {
+            return;
+        }
+        const patch = emptyCephResourceEntry("Pool", poolId, observedAt);
+        switch (data.metricName) {
+            case "ceph_pool_metadata": {
+                // The only pool series that carries the human-readable name.
+                patch.name = getStringAttribute(dpAttributes, "name");
+                cluster.sawPoolMetadata = true;
+                break;
+            }
+            case "ceph_pool_stored": {
+                patch.storedBytes = Math.max(0, Math.trunc(rawValue));
+                break;
+            }
+            case "ceph_pool_max_avail": {
+                patch.maxAvailBytes = Math.max(0, Math.trunc(rawValue));
+                break;
+            }
+            case "ceph_pool_objects": {
+                patch.objects = Math.max(0, Math.trunc(rawValue));
+                break;
+            }
+            /*
+             * Latest RAW cumulative counters — the Pools list computes
+             * IOPS rates on read from ClickHouse, never from these.
+             */
+            case "ceph_pool_rd": {
+                patch.readOpsCounter = Math.max(0, Math.trunc(rawValue));
+                break;
+            }
+            case "ceph_pool_wr": {
+                patch.writeOpsCounter = Math.max(0, Math.trunc(rawValue));
+                break;
+            }
+            default: {
+                return;
+            }
+        }
+        foldCephResourceSnapshot({
+            buffer: data.resourceBuffer,
+            clusterIdStr: data.clusterIdStr,
+            patch,
+        });
+        return;
+    }
+    const cephDaemon = getStringAttribute(dpAttributes, "ceph_daemon");
+    if (!cephDaemon) {
+        return;
+    }
+    const dotIndex = cephDaemon.indexOf(".");
+    const daemonPrefix = dotIndex > 0 ? cephDaemon.substring(0, dotIndex) : "";
+    let kind;
+    if (daemonPrefix === "osd") {
+        kind = "Osd";
+    }
+    else if (daemonPrefix === "mon") {
+        kind = "Mon";
+    }
+    else if (daemonPrefix === "mgr") {
+        kind = "Mgr";
+    }
+    else if (daemonPrefix === "mds") {
+        kind = "Mds";
+    }
+    else if (daemonPrefix === "rgw") {
+        kind = "Rgw";
+    }
+    else {
+        return;
+    }
+    const patch = emptyCephResourceEntry(kind, cephDaemon, observedAt);
+    switch (data.metricName) {
+        case "ceph_mon_quorum_status": {
+            patch.inQuorum = rawValue >= 1;
+            break;
+        }
+        case "ceph_mon_metadata": {
+            patch.hostname = getStringAttribute(dpAttributes, "hostname");
+            patch.daemonVersion = getStringAttribute(dpAttributes, "ceph_version");
+            cluster.sawMonMetadata = true;
+            // CephCluster.cephVersion = modal mon version across the batch.
+            if (patch.daemonVersion) {
+                cluster.cephVersionCounts.set(patch.daemonVersion, (cluster.cephVersionCounts.get(patch.daemonVersion) || 0) + 1);
+            }
+            break;
+        }
+        case "ceph_osd_up": {
+            patch.isUp = rawValue >= 1;
+            cluster.sawOsdUp = true;
+            break;
+        }
+        case "ceph_osd_in": {
+            patch.isIn = rawValue >= 1;
+            cluster.sawOsdIn = true;
+            break;
+        }
+        case "ceph_osd_metadata": {
+            patch.hostname = getStringAttribute(dpAttributes, "hostname");
+            patch.deviceClass = getStringAttribute(dpAttributes, "device_class");
+            patch.daemonVersion = getStringAttribute(dpAttributes, "ceph_version");
+            cluster.sawOsdMetadata = true;
+            break;
+        }
+        case "ceph_mgr_metadata":
+        case "ceph_mds_metadata":
+        case "ceph_rgw_metadata": {
+            patch.hostname = getStringAttribute(dpAttributes, "hostname");
+            patch.daemonVersion = getStringAttribute(dpAttributes, "ceph_version");
+            break;
+        }
+        case "ceph_osd_stat_bytes": {
+            patch.statBytes = Math.max(0, Math.trunc(rawValue));
+            break;
+        }
+        case "ceph_osd_stat_bytes_used": {
+            patch.statBytesUsed = Math.max(0, Math.trunc(rawValue));
+            break;
+        }
+        case "ceph_osd_apply_latency_ms": {
+            patch.applyLatencyMs = Math.max(0, rawValue);
+            break;
+        }
+        case "ceph_osd_commit_latency_ms": {
+            patch.commitLatencyMs = Math.max(0, rawValue);
+            break;
+        }
+        case "ceph_osd_numpg": {
+            patch.pgCount = Math.max(0, Math.trunc(rawValue));
+            break;
+        }
+        default: {
+            return;
+        }
+    }
+    foldCephResourceSnapshot({
+        buffer: data.resourceBuffer,
+        clusterIdStr: data.clusterIdStr,
+        patch,
+    });
+}
+/*
+ * Merge a patch into the per-cluster Ceph buffer — same semantics
+ * as foldProxmoxResourceSnapshot (identity first-non-null-wins,
+ * status/metrics newest-observedAt-wins).
+ */
+export function foldCephResourceSnapshot(data) {
+    let perCluster = data.buffer.get(data.clusterIdStr);
+    if (!perCluster) {
+        perCluster = new Map();
+        data.buffer.set(data.clusterIdStr, perCluster);
+    }
+    const key = `${data.patch.kind}|${data.patch.externalId}`;
+    const existing = perCluster.get(key);
+    if (!existing) {
+        perCluster.set(key, data.patch);
+        return;
+    }
+    const patch = data.patch;
+    const newer = patch.observedAt >= existing.observedAt;
+    // Identity: first-non-null wins.
+    if (existing.name === null && patch.name !== null) {
+        existing.name = patch.name;
+    }
+    if (existing.hostname === null && patch.hostname !== null) {
+        existing.hostname = patch.hostname;
+    }
+    if (existing.daemonVersion === null && patch.daemonVersion !== null) {
+        existing.daemonVersion = patch.daemonVersion;
+    }
+    if (existing.deviceClass === null && patch.deviceClass !== null) {
+        existing.deviceClass = patch.deviceClass;
+    }
+    // Status / metrics: newest observation wins.
+    if (patch.isUp !== null && newer) {
+        existing.isUp = patch.isUp;
+    }
+    if (patch.isIn !== null && newer) {
+        existing.isIn = patch.isIn;
+    }
+    if (patch.inQuorum !== null && newer) {
+        existing.inQuorum = patch.inQuorum;
+    }
+    if (patch.statBytes !== null && newer) {
+        existing.statBytes = patch.statBytes;
+    }
+    if (patch.statBytesUsed !== null && newer) {
+        existing.statBytesUsed = patch.statBytesUsed;
+    }
+    if (patch.applyLatencyMs !== null && newer) {
+        existing.applyLatencyMs = patch.applyLatencyMs;
+    }
+    if (patch.commitLatencyMs !== null && newer) {
+        existing.commitLatencyMs = patch.commitLatencyMs;
+    }
+    if (patch.pgCount !== null && newer) {
+        existing.pgCount = patch.pgCount;
+    }
+    if (patch.storedBytes !== null && newer) {
+        existing.storedBytes = patch.storedBytes;
+    }
+    if (patch.maxAvailBytes !== null && newer) {
+        existing.maxAvailBytes = patch.maxAvailBytes;
+    }
+    if (patch.objects !== null && newer) {
+        existing.objects = patch.objects;
+    }
+    if (patch.readOpsCounter !== null && newer) {
+        existing.readOpsCounter = patch.readOpsCounter;
+    }
+    if (patch.writeOpsCounter !== null && newer) {
+        existing.writeOpsCounter = patch.writeOpsCounter;
+    }
+    if (patch.observedAt > existing.observedAt) {
+        existing.observedAt = patch.observedAt;
+    }
+}
+/*
+ * Derive the CephCluster snapshot columns from one folded batch —
+ * same never-zero-a-count-on-a-partial-batch contract as the Proxmox
+ * derive above.
+ */
+export function deriveCephClusterSnapshotExtras(entries, snap) {
+    const extras = {};
+    if (snap === null || snap === void 0 ? void 0 : snap.sawMonMetadata) {
+        extras.monCount = entries.filter((e) => {
+            return e.kind === "Mon";
+        }).length;
+    }
+    if (snap === null || snap === void 0 ? void 0 : snap.sawOsdMetadata) {
+        extras.osdCount = entries.filter((e) => {
+            return e.kind === "Osd";
+        }).length;
+    }
+    if (snap === null || snap === void 0 ? void 0 : snap.sawOsdUp) {
+        extras.osdUpCount = entries.filter((e) => {
+            return e.kind === "Osd" && e.isUp === true;
+        }).length;
+    }
+    if (snap === null || snap === void 0 ? void 0 : snap.sawOsdIn) {
+        extras.osdInCount = entries.filter((e) => {
+            return e.kind === "Osd" && e.isIn === true;
+        }).length;
+    }
+    if (snap === null || snap === void 0 ? void 0 : snap.sawPoolMetadata) {
+        extras.poolCount = entries.filter((e) => {
+            return e.kind === "Pool";
+        }).length;
+    }
+    if (snap && snap.healthStatus !== null) {
+        extras.healthStatus = snap.healthStatus;
+    }
+    if (snap &&
+        snap.totalBytes !== null &&
+        snap.totalBytes > 0 &&
+        snap.totalUsedBytes !== null) {
+        /*
+         * Round to 2 decimals: full float precision would change the
+         * extras fingerprint on every scrape and defeat the 60-s
+         * write throttle for an invisible difference.
+         */
+        extras.capacityUsedPercent =
+            Math.round((snap.totalUsedBytes / snap.totalBytes) * 10000) / 100;
+    }
+    if (snap && snap.cephVersionCounts.size > 0) {
+        let modalVersion = null;
+        let modalCount = 0;
+        for (const [version, count] of snap.cephVersionCounts.entries()) {
+            if (count > modalCount) {
+                modalVersion = version;
+                modalCount = count;
+            }
+        }
+        if (modalVersion) {
+            extras.cephVersion = modalVersion;
+        }
+    }
+    return extras;
+}
+//# sourceMappingURL=ProxmoxCephSnapshotScan.js.map