@oneuptime/common 10.2.15 → 10.2.17

package/Server/API/DashboardAPI.ts

@@ -346,11 +346,6 @@ export default class DashboardAPI extends BaseAPI<
             throw new BadDataException("attributeKey is required.");
           }
 
-          const metricNameRaw: string | undefined =
-            req.body && (req.body["metricName"] as string);
-          const metricName: string | undefined =
-            metricNameRaw && metricNameRaw.trim() ? metricNameRaw : undefined;
-
           const telemetryTypeRaw: string | undefined =
             req.body && (req.body["telemetryType"] as string);
           let telemetryType: TelemetryType = TelemetryType.Metric;
@@ -386,7 +381,6 @@ export default class DashboardAPI extends BaseAPI<
               projectId: dashboard.projectId,
               telemetryType,
               attributeKey: attributeKey.trim(),
-              metricName,
             });
 
           return Response.sendJsonObjectResponse(req, res, {

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/IncidentService.ts

@@ -49,6 +49,7 @@ import Metric, {
 import OneUptimeDate from "../../Types/Date";
 import TelemetryUtil from "../Utils/Telemetry/Telemetry";
 import logger, { LogAttributes } from "../Utils/Logger";
+import NotEqual from "../../Types/BaseDatabase/NotEqual";
 import IncidentFeedService from "./IncidentFeedService";
 import IncidentSlaService from "./IncidentSlaService";
 import { setIsPublicForMarkdownImages } from "../Utils/InlineImageAccessTokenSync";
@@ -2563,12 +2564,25 @@ ${incidentSeverity.name}
     const firstIncidentStateTimeline: IncidentStateTimeline | undefined =
       incidentStateTimelines[0];
 
-    // delete all the incident metrics with this incident id because it's a refresh.
-
+    /*
+     * Delete the existing metrics for this incident so the time-varying
+     * ones (TimeToAcknowledge / TimeToResolve / IncidentDuration /
+     * TimeInState) get rewritten with the latest state-timeline values
+     * on this refresh. IncidentCount is excluded from the delete: it is
+     * a constant `value = 1` keyed by `serviceId + bucketTime` that
+     * never changes. Re-emitting it across refreshes inflated the
+     * 1-minute aggregating materialized view (`MetricItemAggMV1m_mv`),
+     * because the MV trigger only fires on inserts — ALTER DELETE
+     * mutations don't roll back the previously-accumulated
+     * `sumState` / `countState`. That's why the Incident Dashboard
+     * sum-of-IncidentCount widget read ~33% higher than the actual
+     * unique-incident count.
+     */
     await MetricService.deleteBy({
       query: {
         projectId: incident.projectId,
         serviceId: data.incidentId,
+        name: new NotEqual<string>(IncidentMetricType.IncidentCount),
       },
       props: {
         isRoot: true,
@@ -2623,36 +2637,59 @@ ${incidentSeverity.name}
       ownerTeamNames: ownerTeamNames.join(", "),
     };
 
-    const incidentCountMetric: Metric = new Metric();
+    /*
+     * Only emit IncidentCount on the very first refresh (i.e. when no
+     * existing IncidentCount row is present for this serviceId). See
+     * the delete comment above — emitting it on every refresh would
+     * accumulate phantom `sumState` entries in the MV that ALTER
+     * DELETE can't undo. By keeping the original row alive and never
+     * re-emitting, the dashboard Sum stays equal to the true count of
+     * distinct incidents.
+     */
+    const existingIncidentCount: PositiveNumber = await MetricService.countBy({
+      query: {
+        projectId: incident.projectId,
+        serviceId: data.incidentId,
+        name: IncidentMetricType.IncidentCount,
+      },
+      skip: 0,
+      limit: 1,
+      props: {
+        isRoot: true,
+      },
+    });
 
-    incidentCountMetric.projectId = incident.projectId;
-    incidentCountMetric.serviceId = incident.id!;
-    incidentCountMetric.serviceType = ServiceType.Incident;
-    incidentCountMetric.name = IncidentMetricType.IncidentCount;
-    incidentCountMetric.value = 1;
-    incidentCountMetric.attributes = { ...baseMetricAttributes };
-    incidentCountMetric.attributeKeys = TelemetryUtil.getAttributeKeys(
-      incidentCountMetric.attributes,
-    );
+    if (existingIncidentCount.toNumber() === 0) {
+      const incidentCountMetric: Metric = new Metric();
+
+      incidentCountMetric.projectId = incident.projectId;
+      incidentCountMetric.serviceId = incident.id!;
+      incidentCountMetric.serviceType = ServiceType.Incident;
+      incidentCountMetric.name = IncidentMetricType.IncidentCount;
+      incidentCountMetric.value = 1;
+      incidentCountMetric.attributes = { ...baseMetricAttributes };
+      incidentCountMetric.attributeKeys = TelemetryUtil.getAttributeKeys(
+        incidentCountMetric.attributes,
+      );
 
-    incidentCountMetric.time = incidentStartsAt;
-    incidentCountMetric.timeUnixNano = OneUptimeDate.toUnixNano(
-      incidentCountMetric.time,
-    );
-    incidentCountMetric.metricPointType = MetricPointType.Sum;
-    incidentCountMetric.retentionDate = incidentMetricRetentionDate;
+      incidentCountMetric.time = incidentStartsAt;
+      incidentCountMetric.timeUnixNano = OneUptimeDate.toUnixNano(
+        incidentCountMetric.time,
+      );
+      incidentCountMetric.metricPointType = MetricPointType.Sum;
+      incidentCountMetric.retentionDate = incidentMetricRetentionDate;
 
-    itemsToSave.push(incidentCountMetric);
+      itemsToSave.push(incidentCountMetric);
+    }
 
-    // add metric type for this to map.
+    // Always register the metric type so it shows up in the type catalog.
     const metricType: MetricType = new MetricType();
-    metricType.name = incidentCountMetric.name;
+    metricType.name = IncidentMetricType.IncidentCount;
     metricType.description = "Number of incidents created";
     metricType.unit = "";
     metricType.services = [];
 
-    // add to map.
-    metricTypesMap[incidentCountMetric.name] = metricType;
+    metricTypesMap[IncidentMetricType.IncidentCount] = metricType;
 
     // is the incident acknowledged?
     const isIncidentAcknowledged: boolean = incidentStateTimelines.some(

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;
   };
 }