@oneuptime/common 10.2.16 → 10.2.18

package/Server/Services/DockerHostService.ts

@@ -1,16 +1,21 @@
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/DockerHost";
+import Label from "../../Models/DatabaseModels/Label";
 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 from "../Utils/Logger";
 import crypto from "crypto";
 
 const LAST_SEEN_CACHE_NAMESPACE: string = "docker-host-last-seen";
 const LAST_SEEN_THROTTLE_SECONDS: number = 60;
 
+const LABELS_APPLIED_CACHE_NAMESPACE: string = "docker-host-labels-applied";
+const LABELS_APPLIED_CACHE_TTL_SECONDS: number = 60;
+
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
@@ -145,6 +150,83 @@ export class Service extends DatabaseService<Model> {
     });
   }
 
+  /**
+   * Additively attach labels to a Docker 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: {
+    dockerHostId: ObjectID;
+    labelIds: Array<ObjectID>;
+  }): Promise<void> {
+    if (!data.labelIds || data.labelIds.length === 0) {
+      return;
+    }
+
+    const cacheKey: string = data.dockerHostId.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 dockerHostIdStr: string = data.dockerHostId.toString();
+      const existingLabels: Array<Label> = await this.getRepository()
+        .createQueryBuilder()
+        .relation(Model, "labels")
+        .of(dockerHostIdStr)
+        .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(dockerHostIdStr)
+          .add(toAddIds);
+      }
+
+      await GlobalCache.setString(
+        LABELS_APPLIED_CACHE_NAMESPACE,
+        cacheKey,
+        fingerprint,
+        { expiresInSeconds: LABELS_APPLIED_CACHE_TTL_SECONDS },
+      );
+    } catch (err) {
+      logger.warn(
+        `DockerHostService.attachLabels failed for docker host ${data.dockerHostId.toString()}: ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      );
+    }
+  }
+
   @CaptureSpan()
   public async markDisconnectedHosts(): Promise<void> {
     const fiveMinutesAgo: Date = OneUptimeDate.addRemoveMinutes(
@@ -183,4 +265,13 @@ export class Service extends DatabaseService<Model> {
   }
 }
 
+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();

package/Server/Services/KubernetesClusterService.ts

@@ -1,15 +1,21 @@
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/KubernetesCluster";
+import Label from "../../Models/DatabaseModels/Label";
 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 from "../Utils/Logger";
+import crypto from "crypto";
 
 const LAST_SEEN_CACHE_NAMESPACE: string = "k8s-cluster-last-seen";
 const LAST_SEEN_THROTTLE_SECONDS: number = 60;
 
+const LABELS_APPLIED_CACHE_NAMESPACE: string = "k8s-cluster-labels-applied";
+const LABELS_APPLIED_CACHE_TTL_SECONDS: number = 60;
+
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
@@ -116,6 +122,83 @@ export class Service extends DatabaseService<Model> {
     });
   }
 
+  /**
+   * Additively attach labels to a Kubernetes cluster. 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: {
+    kubernetesClusterId: ObjectID;
+    labelIds: Array<ObjectID>;
+  }): Promise<void> {
+    if (!data.labelIds || data.labelIds.length === 0) {
+      return;
+    }
+
+    const cacheKey: string = data.kubernetesClusterId.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 clusterIdStr: string = data.kubernetesClusterId.toString();
+      const existingLabels: Array<Label> = await this.getRepository()
+        .createQueryBuilder()
+        .relation(Model, "labels")
+        .of(clusterIdStr)
+        .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(clusterIdStr)
+          .add(toAddIds);
+      }
+
+      await GlobalCache.setString(
+        LABELS_APPLIED_CACHE_NAMESPACE,
+        cacheKey,
+        fingerprint,
+        { expiresInSeconds: LABELS_APPLIED_CACHE_TTL_SECONDS },
+      );
+    } catch (err) {
+      logger.warn(
+        `KubernetesClusterService.attachLabels failed for cluster ${data.kubernetesClusterId.toString()}: ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      );
+    }
+  }
+
   @CaptureSpan()
   public async markDisconnectedClusters(): Promise<void> {
     const fiveMinutesAgo: Date = OneUptimeDate.addRemoveMinutes(
@@ -154,4 +237,13 @@ export class Service extends DatabaseService<Model> {
   }
 }
 
+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();

package/Types/Dashboard/DashboardComponents/DashboardValueComponent.ts

@@ -3,6 +3,20 @@ import ObjectID from "../../ObjectID";
 import DashboardComponentType from "../DashboardComponentType";
 import BaseComponent from "./DashboardBaseComponent";
 
+/*
+ * "Auto" defers to a metric-name heuristic in ValueFormatter
+ * (`isHigherWorseMetric`) — that lets templates skip the field unless
+ * they need to override. "HigherIsBetter" forces ↑ = green / ↓ = red
+ * (e.g. uptime, throughput, success rate). "HigherIsWorse" inverts so a
+ * rising incident count, error rate, latency, or restart count is shown
+ * in red.
+ */
+export enum DashboardValueTrendDirection {
+  Auto = "Auto",
+  HigherIsBetter = "HigherIsBetter",
+  HigherIsWorse = "HigherIsWorse",
+}
+
 export default interface DashboardValueComponent extends BaseComponent {
   componentType: DashboardComponentType.Value;
   componentId: ObjectID;
@@ -11,5 +25,6 @@ export default interface DashboardValueComponent extends BaseComponent {
     title: string;
     warningThreshold?: number | undefined;
     criticalThreshold?: number | undefined;
+    trendDirection?: DashboardValueTrendDirection | undefined;
   };
 }

package/Types/Dashboard/DashboardTemplates.ts

@@ -10,6 +10,7 @@ import MetricsAggregationType from "../Metrics/MetricsAggregationType";
 import IncidentMetricType from "../Incident/IncidentMetricType";
 import MonitorMetricType from "../Monitor/MonitorMetricType";
 import MetricDashboardMetricType from "../Metrics/MetricDashboardMetricType";
+import { DashboardValueTrendDirection } from "./DashboardComponents/DashboardValueComponent";
 
 /*
  * Trace / Exception / Profiles entries are intentionally not in this
@@ -147,6 +148,13 @@ function createValueComponent(data: {
   left: number;
   width: number;
   metricConfig?: MetricConfig;
+  /*
+   * Per-widget override for the trend-arrow colour. Leave `undefined` to
+   * let the renderer apply its metric-name heuristic (incident counts,
+   * error rates, latency, CPU/memory usage flip the colour); set
+   * explicitly when the heuristic would guess wrong.
+   */
+  trendDirection?: DashboardValueTrendDirection;
 }): DashboardBaseComponent {
   return {
     _type: ObjectType.DashboardComponent,
@@ -168,6 +176,7 @@ function createValueComponent(data: {
               groupBy: undefined,
             },
           },
+      trendDirection: data.trendDirection,
     },
   };
 }
@@ -390,6 +399,7 @@ function createMonitorDashboardConfig(): DashboardViewConfig {
         aggregationType: MetricsAggregationType.Avg,
         legendUnit: "ms",
       },
+      trendDirection: DashboardValueTrendDirection.HigherIsWorse,
     }),
     /*
      * IsOnline is emitted as 0/1 with unit "" by MonitorMetricUtil, so
@@ -407,6 +417,7 @@ function createMonitorDashboardConfig(): DashboardViewConfig {
         metricName: MonitorMetricType.IsOnline,
         aggregationType: MetricsAggregationType.Avg,
       },
+      trendDirection: DashboardValueTrendDirection.HigherIsBetter,
     }),
     /*
      * ResponseStatusCode is the literal HTTP status code (200, 404,
@@ -424,6 +435,7 @@ function createMonitorDashboardConfig(): DashboardViewConfig {
         metricName: MonitorMetricType.ResponseStatusCode,
         aggregationType: MetricsAggregationType.Count,
       },
+      trendDirection: DashboardValueTrendDirection.HigherIsBetter,
     }),
     createValueComponent({
       title: "Execution Time",
@@ -435,6 +447,7 @@ function createMonitorDashboardConfig(): DashboardViewConfig {
         aggregationType: MetricsAggregationType.Avg,
         legendUnit: "ms",
       },
+      trendDirection: DashboardValueTrendDirection.HigherIsWorse,
     }),
 
     // Row 2-4: Charts
@@ -586,7 +599,7 @@ function createIncidentDashboardConfig(): DashboardViewConfig {
       isBold: true,
     }),
 
-    // Row 1: Key incident metrics
+    // Row 1: Key incident metrics — every one is "higher = worse".
     createValueComponent({
       title: "Incident Count",
       top: 1,
@@ -596,6 +609,7 @@ function createIncidentDashboardConfig(): DashboardViewConfig {
         metricName: IncidentMetricType.IncidentCount,
         aggregationType: MetricsAggregationType.Sum,
       },
+      trendDirection: DashboardValueTrendDirection.HigherIsWorse,
     }),
     createValueComponent({
       title: "MTTR",
@@ -606,6 +620,7 @@ function createIncidentDashboardConfig(): DashboardViewConfig {
         metricName: IncidentMetricType.TimeToResolve,
         aggregationType: MetricsAggregationType.Avg,
       },
+      trendDirection: DashboardValueTrendDirection.HigherIsWorse,
     }),
     createValueComponent({
       title: "MTTA",
@@ -616,6 +631,7 @@ function createIncidentDashboardConfig(): DashboardViewConfig {
         metricName: IncidentMetricType.TimeToAcknowledge,
         aggregationType: MetricsAggregationType.Avg,
       },
+      trendDirection: DashboardValueTrendDirection.HigherIsWorse,
     }),
     createValueComponent({
       title: "Avg Duration",
@@ -626,6 +642,7 @@ function createIncidentDashboardConfig(): DashboardViewConfig {
         metricName: IncidentMetricType.IncidentDuration,
         aggregationType: MetricsAggregationType.Avg,
       },
+      trendDirection: DashboardValueTrendDirection.HigherIsWorse,
     }),
 
     // Row 2-4: Incident trends
@@ -843,6 +860,7 @@ function createKubernetesDashboardConfig(): DashboardViewConfig {
     /*
      * Row 1: Key cluster metrics — averages render with proper units via
      * ValueFormatter (CPU utilization → "%", memory.usage → "MB"/"GB").
+     * All four are "higher = worse" (closer to capacity = bad).
      */
     createValueComponent({
       title: "Pod CPU (avg)",
@@ -853,6 +871,7 @@ function createKubernetesDashboardConfig(): DashboardViewConfig {
         metricName: "k8s.pod.cpu.utilization",
         aggregationType: MetricsAggregationType.Avg,
       },
+      trendDirection: DashboardValueTrendDirection.HigherIsWorse,
     }),
     createValueComponent({
       title: "Pod Memory (avg)",
@@ -863,6 +882,7 @@ function createKubernetesDashboardConfig(): DashboardViewConfig {
         metricName: "k8s.pod.memory.usage",
         aggregationType: MetricsAggregationType.Avg,
       },
+      trendDirection: DashboardValueTrendDirection.HigherIsWorse,
     }),
     createValueComponent({
       title: "Node CPU (avg)",
@@ -873,6 +893,7 @@ function createKubernetesDashboardConfig(): DashboardViewConfig {
         metricName: "k8s.node.cpu.utilization",
         aggregationType: MetricsAggregationType.Avg,
       },
+      trendDirection: DashboardValueTrendDirection.HigherIsWorse,
     }),
     createValueComponent({
       title: "Node Memory (avg)",
@@ -883,6 +904,7 @@ function createKubernetesDashboardConfig(): DashboardViewConfig {
         metricName: "k8s.node.memory.usage",
         aggregationType: MetricsAggregationType.Avg,
       },
+      trendDirection: DashboardValueTrendDirection.HigherIsWorse,
     }),
 
     // Row 2-4: Resource usage charts
@@ -1075,7 +1097,11 @@ function createMetricsDashboardConfig(): DashboardViewConfig {
       isBold: true,
     }),
 
-    // Row 1: Key HTTP metrics
+    /*
+     * Row 1: Key HTTP metrics. Request volume rising is generally a
+     * sign of activity (good); latency, errors, and active in-flight
+     * requests rising signal saturation or trouble (bad).
+     */
     createValueComponent({
       title: "Request Rate",
       top: 1,
@@ -1086,6 +1112,7 @@ function createMetricsDashboardConfig(): DashboardViewConfig {
         aggregationType: MetricsAggregationType.Sum,
         legendUnit: "req/s",
       },
+      trendDirection: DashboardValueTrendDirection.HigherIsBetter,
     }),
     createValueComponent({
       title: "Avg Latency",
@@ -1097,6 +1124,7 @@ function createMetricsDashboardConfig(): DashboardViewConfig {
         aggregationType: MetricsAggregationType.Avg,
         legendUnit: "ms",
       },
+      trendDirection: DashboardValueTrendDirection.HigherIsWorse,
     }),
     createValueComponent({
       title: "Error Rate",
@@ -1108,6 +1136,7 @@ function createMetricsDashboardConfig(): DashboardViewConfig {
         aggregationType: MetricsAggregationType.Avg,
         legendUnit: "%",
       },
+      trendDirection: DashboardValueTrendDirection.HigherIsWorse,
     }),
     createValueComponent({
       title: "Active Requests",
@@ -1118,6 +1147,7 @@ function createMetricsDashboardConfig(): DashboardViewConfig {
         metricName: MetricDashboardMetricType.HttpActiveRequests,
         aggregationType: MetricsAggregationType.Avg,
       },
+      trendDirection: DashboardValueTrendDirection.HigherIsWorse,
     }),
 
     // Row 2-4: HTTP request charts
@@ -1230,6 +1260,7 @@ function createMetricsDashboardConfig(): DashboardViewConfig {
         metricName: MetricDashboardMetricType.SystemMemoryUsage,
         aggregationType: MetricsAggregationType.Avg,
       },
+      trendDirection: DashboardValueTrendDirection.HigherIsWorse,
     }),
     createChartComponent({
       title: "CPU Usage Over Time",

package/Utils/Dashboard/Components/DashboardValueComponent.ts

@@ -3,7 +3,9 @@ import {
   ComponentArgumentSection,
   ComponentInputType,
 } from "../../../Types/Dashboard/DashboardComponents/ComponentArgument";
-import DashboardValueComponent from "../../../Types/Dashboard/DashboardComponents/DashboardValueComponent";
+import DashboardValueComponent, {
+  DashboardValueTrendDirection,
+} from "../../../Types/Dashboard/DashboardComponents/DashboardValueComponent";
 import DashboardComponentType from "../../../Types/Dashboard/DashboardComponentType";
 import { ObjectType } from "../../../Types/JSON";
 import ObjectID from "../../../Types/ObjectID";
@@ -15,10 +17,17 @@ const DataSourceSection: ComponentArgumentSection = {
   order: 1,
 };
 
+const DisplaySection: ComponentArgumentSection = {
+  name: "Display",
+  description: "Tune how the trend arrow is coloured",
+  order: 2,
+  defaultCollapsed: true,
+};
+
 const ThresholdsSection: ComponentArgumentSection = {
   name: "Thresholds",
   description: "Set warning and critical levels",
-  order: 2,
+  order: 3,
   defaultCollapsed: true,
 };
 
@@ -71,6 +80,31 @@ export default class DashboardValueComponentUtil extends DashboardBaseComponentU
       section: DataSourceSection,
     });
 
+    componentArguments.push({
+      name: "Trend Direction",
+      description:
+        "How the trend arrow is coloured. Auto reads the metric name (e.g. 'error_count' and 'latency' are treated as 'higher is worse'). Pick a value to override.",
+      required: false,
+      type: ComponentInputType.Dropdown,
+      id: "trendDirection",
+      isAdvanced: true,
+      section: DisplaySection,
+      dropdownOptions: [
+        {
+          label: "Auto (detect from metric name)",
+          value: DashboardValueTrendDirection.Auto,
+        },
+        {
+          label: "Higher is better (↑ green)",
+          value: DashboardValueTrendDirection.HigherIsBetter,
+        },
+        {
+          label: "Higher is worse (↑ red)",
+          value: DashboardValueTrendDirection.HigherIsWorse,
+        },
+      ],
+    });
+
     componentArguments.push({
       name: "Warning Threshold",
       description: "Yellow background when value exceeds this",

package/Utils/ValueFormatter.ts

@@ -435,6 +435,42 @@ export default class ValueFormatter {
     return fractionMetricSuffixRegex.test(metricName);
   }
 
+  /*
+   * Direction-of-goodness heuristic for trend coloring. Returns true when a
+   * rising value on this metric should be shown as bad (red ↑) and a falling
+   * value as good (green ↓) — the opposite of the default "up = good".
+   *
+   * Caller is responsible for the inversion; this method only classifies.
+   * Conservative by default: when the metric name carries no signal we
+   * return `false` so generic counters (request rate, network I/O, span
+   * count) keep the up = good colour scheme. Explicit "higher is better"
+   * tokens (uptime/availability/online/ready/healthy/available/success/
+   * passed) take precedence — without that allowlist `oneuptime.monitor.
+   * online` would match nothing and incorrectly fall through; the suffix
+   * test then catches incident counts, error rates, MTTR/MTTA, response
+   * times, CPU/memory usage, restarts, pressure, queue backlogs, etc.
+   *
+   * Adding a metric here is a single regex edit. If a dashboard widget
+   * really needs to override this for a specific case, callers can set
+   * `higherIsBetter` explicitly on the trend display.
+   */
+  public static isHigherWorseMetric(metricName: string | undefined): boolean {
+    if (!metricName) {
+      return false;
+    }
+    const lower: string = metricName.toLowerCase();
+
+    const higherIsBetter: RegExp =
+      /\b(uptime|availability|online|ready|healthy|available|success|passed|ok|alive|up)\b/;
+    if (higherIsBetter.test(lower)) {
+      return false;
+    }
+
+    const higherIsWorse: RegExp =
+      /(error|fail(?:ure|ed)?|incident|exception|crash|restart|timeout|dropped|aborted?|reject(?:ed)?|mttr|mtta|latenc(?:y|ies)|duration|[._-]time\b|time[._-]to[._-]|usage|utilization|pressure|unresolved|pending|backlog|lag|delay|saturation|throttl|stall|missed?)/;
+    return higherIsWorse.test(lower);
+  }
+
   // Check if a unit is one we can auto-scale (bytes, seconds, etc.)
   public static isScalableUnit(unit: string): boolean {
     if (!unit || unit.trim() === "") {

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

@@ -15,9 +15,12 @@ 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 = "docker-host-last-seen";
 const LAST_SEEN_THROTTLE_SECONDS = 60;
+const LABELS_APPLIED_CACHE_NAMESPACE = "docker-host-labels-applied";
+const LABELS_APPLIED_CACHE_TTL_SECONDS = 60;
 export class Service extends DatabaseService {
     constructor() {
         super(Model);
@@ -116,6 +119,62 @@ export class Service extends DatabaseService {
             },
         });
     }
+    /**
+     * Additively attach labels to a Docker 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.
+     */
+    async attachLabels(data) {
+        var _a;
+        if (!data.labelIds || data.labelIds.length === 0) {
+            return;
+        }
+        const cacheKey = data.dockerHostId.toString();
+        const fingerprint = fingerprintLabelIds(data.labelIds);
+        const cached = await GlobalCache.getString(LABELS_APPLIED_CACHE_NAMESPACE, cacheKey);
+        if (cached === fingerprint) {
+            return;
+        }
+        try {
+            const dockerHostIdStr = data.dockerHostId.toString();
+            const existingLabels = await this.getRepository()
+                .createQueryBuilder()
+                .relation(Model, "labels")
+                .of(dockerHostIdStr)
+                .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(dockerHostIdStr)
+                    .add(toAddIds);
+            }
+            await GlobalCache.setString(LABELS_APPLIED_CACHE_NAMESPACE, cacheKey, fingerprint, { expiresInSeconds: LABELS_APPLIED_CACHE_TTL_SECONDS });
+        }
+        catch (err) {
+            logger.warn(`DockerHostService.attachLabels failed for docker host ${data.dockerHostId.toString()}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     async markDisconnectedHosts() {
         const fiveMinutesAgo = OneUptimeDate.addRemoveMinutes(OneUptimeDate.getCurrentDate(), -5);
         const connectedHosts = await this.findBy({
@@ -159,11 +218,25 @@ __decorate([
     __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, "markDisconnectedHosts", 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=DockerHostService.js.map