@oneuptime/common 10.0.93 → 10.0.94

package/Server/Services/DockerResourceService.ts

@@ -0,0 +1,310 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/DockerResource";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import ObjectID from "../../Types/ObjectID";
+import OneUptimeDate from "../../Types/Date";
+import { JSONObject } from "../../Types/JSON";
+import logger from "../Utils/Logger";
+
+/*
+ * ------------------------------------------------------------------
+ * DockerResourceService
+ *
+ * Writes and reads the Docker inventory table populated by the
+ * telemetry ingest path. Container rows are upserted from the
+ * docker_stats receiver metric stream — every container.* metric
+ * carries container.id / container.name / container.image.name
+ * resource attributes, which is enough to maintain a live inventory
+ * of running containers per host without any agent-side change.
+ *
+ * Image / Network / Volume kinds are reserved for a follow-up agent
+ * change that adds a snapshot poller; the schema is ready for them.
+ *
+ * Rows are hard-deleted once lastSeenAt falls behind the staleness
+ * threshold (default: 15 min) so containers that stopped emitting
+ * metrics fall off the list automatically.
+ * ------------------------------------------------------------------
+ */
+
+export interface ParsedDockerContainer {
+  containerName: string;
+  containerId: string | null;
+  imageName: string | null;
+  state: string;
+  cpuPercent: number | null;
+  memoryBytes: number | null;
+  observedAt: Date;
+}
+
+export interface ParsedDockerResource {
+  kind: string;
+  name: string;
+  containerId: string | null;
+  imageName: string | null;
+  state: string | null;
+  labels: JSONObject | null;
+  resourceCreationTimestamp: Date | null;
+  lastSeenAt: Date;
+}
+
+export interface DockerHostInventoryCounts {
+  containersRunning: number;
+  containersStopped: number;
+  containersPaused: number;
+}
+
+const UPSERT_BATCH_SIZE: number = 500;
+const STALE_DELETE_WARN_THRESHOLD: number = 100;
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  /**
+   * Upsert a batch of Container rows for a single (project, host)
+   * pair. Uses ON CONFLICT on the UNIQUE (projectId, dockerHostId,
+   * kind, name) index with a dominance guard on lastSeenAt so
+   * out-of-order ingest never regresses a newer observation.
+   *
+   * Containers are upserted from metric snapshots (no separate
+   * inventory snapshot path), so this also writes
+   * latestCpuPercent / latestMemoryBytes / metricsUpdatedAt in the
+   * same statement — saves a round trip vs. the K8s pattern of
+   * upsert-then-update.
+   */
+  @CaptureSpan()
+  public async bulkUpsertContainers(data: {
+    projectId: ObjectID;
+    dockerHostId: ObjectID;
+    containers: Array<ParsedDockerContainer>;
+  }): Promise<void> {
+    if (data.containers.length === 0) {
+      return;
+    }
+
+    for (
+      let i: number = 0;
+      i < data.containers.length;
+      i += UPSERT_BATCH_SIZE
+    ) {
+      const chunk: Array<ParsedDockerContainer> = data.containers.slice(
+        i,
+        i + UPSERT_BATCH_SIZE,
+      );
+
+      const valueFragments: Array<string> = [];
+      const params: Array<unknown> = [];
+      let p: number = 1;
+
+      for (const c of chunk) {
+        valueFragments.push(
+          `($${p++}, $${p++}, $${p++}, $${p++}, $${p++}, $${p++}, $${p++}, $${p++}::numeric, $${p++}::bigint, $${p++}::timestamptz, $${p++}::timestamptz, $${p++})`,
+        );
+        params.push(
+          data.projectId.toString(),
+          data.dockerHostId.toString(),
+          "Container",
+          c.containerName,
+          c.containerId,
+          c.imageName,
+          c.state,
+          c.cpuPercent !== null && c.cpuPercent !== undefined
+            ? c.cpuPercent
+            : null,
+          c.memoryBytes !== null && c.memoryBytes !== undefined
+            ? Math.trunc(c.memoryBytes).toString()
+            : null,
+          c.observedAt,
+          c.observedAt,
+          0, // version (BaseModel @VersionColumn)
+        );
+      }
+
+      const sql: string = `
+        INSERT INTO "DockerResource" (
+          "projectId", "dockerHostId", "kind", "name",
+          "containerId", "imageName", "state",
+          "latestCpuPercent", "latestMemoryBytes",
+          "metricsUpdatedAt", "lastSeenAt", "version"
+        )
+        VALUES ${valueFragments.join(", ")}
+        ON CONFLICT ("projectId", "dockerHostId", "kind", "name")
+        DO UPDATE SET
+          "containerId" = COALESCE(EXCLUDED."containerId", "DockerResource"."containerId"),
+          "imageName" = COALESCE(EXCLUDED."imageName", "DockerResource"."imageName"),
+          "state" = EXCLUDED."state",
+          "latestCpuPercent" = COALESCE(EXCLUDED."latestCpuPercent", "DockerResource"."latestCpuPercent"),
+          "latestMemoryBytes" = COALESCE(EXCLUDED."latestMemoryBytes", "DockerResource"."latestMemoryBytes"),
+          "metricsUpdatedAt" = EXCLUDED."metricsUpdatedAt",
+          "lastSeenAt" = EXCLUDED."lastSeenAt",
+          "updatedAt" = now()
+        WHERE EXCLUDED."lastSeenAt" >= "DockerResource"."lastSeenAt"
+      `;
+
+      await this.getRepository().manager.query(sql, params);
+    }
+  }
+
+  /**
+   * Upsert a batch of resources for any kind. Used by the snapshot
+   * ingest path (Container / Image / Network / Volume rows from the
+   * Docker agent's inventory poller). Container rows from this path
+   * carry full state (running / exited / paused / restarting / dead /
+   * created), unlike the metric-derived path which only sees running
+   * containers.
+   */
+  @CaptureSpan()
+  public async bulkUpsert(data: {
+    projectId: ObjectID;
+    dockerHostId: ObjectID;
+    resources: Array<ParsedDockerResource>;
+  }): Promise<void> {
+    if (data.resources.length === 0) {
+      return;
+    }
+
+    for (let i: number = 0; i < data.resources.length; i += UPSERT_BATCH_SIZE) {
+      const chunk: Array<ParsedDockerResource> = data.resources.slice(
+        i,
+        i + UPSERT_BATCH_SIZE,
+      );
+
+      const valueFragments: Array<string> = [];
+      const params: Array<unknown> = [];
+      let p: number = 1;
+
+      for (const r of chunk) {
+        valueFragments.push(
+          `($${p++}, $${p++}, $${p++}, $${p++}, $${p++}, $${p++}, $${p++}, $${p++}, $${p++}::timestamptz, $${p++}::timestamptz, $${p++})`,
+        );
+        params.push(
+          data.projectId.toString(),
+          data.dockerHostId.toString(),
+          r.kind,
+          r.name,
+          r.containerId,
+          r.imageName,
+          r.state,
+          r.labels ? JSON.stringify(r.labels) : null,
+          r.resourceCreationTimestamp,
+          r.lastSeenAt,
+          0, // version
+        );
+      }
+
+      const sql: string = `
+        INSERT INTO "DockerResource" (
+          "projectId", "dockerHostId", "kind", "name",
+          "containerId", "imageName", "state", "labels",
+          "resourceCreationTimestamp", "lastSeenAt", "version"
+        )
+        VALUES ${valueFragments.join(", ")}
+        ON CONFLICT ("projectId", "dockerHostId", "kind", "name")
+        DO UPDATE SET
+          "containerId" = COALESCE(EXCLUDED."containerId", "DockerResource"."containerId"),
+          "imageName" = COALESCE(EXCLUDED."imageName", "DockerResource"."imageName"),
+          "state" = COALESCE(EXCLUDED."state", "DockerResource"."state"),
+          "labels" = COALESCE(EXCLUDED."labels", "DockerResource"."labels"),
+          "resourceCreationTimestamp" = COALESCE(EXCLUDED."resourceCreationTimestamp", "DockerResource"."resourceCreationTimestamp"),
+          "lastSeenAt" = EXCLUDED."lastSeenAt",
+          "updatedAt" = now()
+        WHERE EXCLUDED."lastSeenAt" >= "DockerResource"."lastSeenAt"
+      `;
+
+      await this.getRepository().manager.query(sql, params);
+    }
+  }
+
+  /**
+   * Hard-delete all resources on a host whose last observation is
+   * older than olderThan. Returns the number of deleted rows.
+   */
+  @CaptureSpan()
+  public async deleteStaleForHost(data: {
+    dockerHostId: ObjectID;
+    olderThan: Date;
+  }): Promise<number> {
+    const result: Array<{ affected?: number }> | { affected?: number } =
+      await this.getRepository().manager.query(
+        `DELETE FROM "DockerResource" WHERE "dockerHostId" = $1 AND "lastSeenAt" < $2`,
+        [data.dockerHostId.toString(), data.olderThan],
+      );
+
+    let affected: number = 0;
+    if (Array.isArray(result) && result.length >= 2) {
+      const second: unknown = (result as Array<unknown>)[1];
+      if (typeof second === "number") {
+        affected = second;
+      }
+    }
+
+    if (affected > STALE_DELETE_WARN_THRESHOLD) {
+      logger.warn(
+        `DockerResource cleanup deleted ${affected} stale rows for host ${data.dockerHostId.toString()} — larger than expected; investigate agent health.`,
+      );
+    }
+
+    return affected;
+  }
+
+  /**
+   * Compute container state breakdowns for a single host from the
+   * inventory table. Used by the cleanup worker to refresh the cached
+   * counts on DockerHost so the Hosts page / dashboard widget shows
+   * accurate numbers without needing a SQL aggregation per render.
+   */
+  @CaptureSpan()
+  public async getContainerCountsForHost(data: {
+    projectId: ObjectID;
+    dockerHostId: ObjectID;
+  }): Promise<DockerHostInventoryCounts> {
+    const rows: Array<{
+      running: string;
+      stopped: string;
+      paused: string;
+    }> = await this.getRepository().manager.query(
+      `SELECT
+         COUNT(*) FILTER (WHERE LOWER("state") = 'running')::text AS "running",
+         COUNT(*) FILTER (WHERE LOWER("state") IN ('exited', 'dead', 'created'))::text AS "stopped",
+         COUNT(*) FILTER (WHERE LOWER("state") = 'paused')::text AS "paused"
+       FROM "DockerResource"
+       WHERE "projectId" = $1
+         AND "dockerHostId" = $2
+         AND "kind" = 'Container'
+         AND "deletedAt" IS NULL`,
+      [data.projectId.toString(), data.dockerHostId.toString()],
+    );
+
+    const row:
+      | { running: string; stopped: string; paused: string }
+      | undefined = rows[0];
+    return {
+      containersRunning: row ? parseInt(row.running, 10) || 0 : 0,
+      containersStopped: row ? parseInt(row.stopped, 10) || 0 : 0,
+      containersPaused: row ? parseInt(row.paused, 10) || 0 : 0,
+    };
+  }
+
+  public getStaleThresholdDate(nowOverride?: Date): Date {
+    const minutes: number = this.getStaleThresholdMinutes();
+    return OneUptimeDate.addRemoveMinutes(
+      nowOverride || OneUptimeDate.getCurrentDate(),
+      -minutes,
+    );
+  }
+
+  public getStaleThresholdMinutes(): number {
+    const raw: string | undefined =
+      process.env["DOCKER_INVENTORY_STALE_MINUTES"];
+    if (raw) {
+      const parsed: number = parseInt(raw, 10);
+      if (!isNaN(parsed) && parsed >= 5) {
+        return parsed;
+      }
+    }
+    return 15;
+  }
+}
+
+export default new Service();

package/Server/Services/MonitorTemplateService.ts

@@ -1,9 +1,368 @@
 import DatabaseService from "./DatabaseService";
+import MonitorService from "./MonitorService";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import BadDataException from "../../Types/Exception/BadDataException";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import ObjectID from "../../Types/ObjectID";
+import PositiveNumber from "../../Types/PositiveNumber";
 import Model from "../../Models/DatabaseModels/MonitorTemplate";
+import Monitor from "../../Models/DatabaseModels/Monitor";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+
+export interface SyncLinkedMonitorsResult {
+  totalLinkedMonitors: number;
+  syncedMonitors: number;
+}
+
+/**
+ * Subset of Monitor fields that a template push can overwrite. Anything
+ * outside this set (name, description, labels, monitorType, etc.) is
+ * intentionally never touched by sync — those are per-monitor concerns.
+ */
+export type SyncableTemplateField =
+  | "monitorSteps"
+  | "monitoringInterval"
+  | "minimumProbeAgreement";
+
+const ALL_SYNCABLE_FIELDS: ReadonlyArray<SyncableTemplateField> = [
+  "monitorSteps",
+  "monitoringInterval",
+  "minimumProbeAgreement",
+];
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  /**
+   * Count monitors created from this template.
+   * Caller must already have read access on the template via the API layer.
+   */
+  @CaptureSpan()
+  public async countLinkedMonitors(data: {
+    monitorTemplateId: ObjectID;
+    projectId: ObjectID;
+  }): Promise<number> {
+    const count: PositiveNumber = await MonitorService.countBy({
+      query: {
+        monitorTemplateId: data.monitorTemplateId,
+        projectId: data.projectId,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return count.toNumber();
+  }
+
+  /**
+   * Validate and narrow a list of field names to the syncable subset.
+   * Anything not in the whitelist throws — we never silently drop a field the
+   * caller asked for, that would mask UI bugs.
+   */
+  private validateSyncableFields(
+    fields: Array<string> | undefined,
+  ): Array<SyncableTemplateField> {
+    if (!fields || fields.length === 0) {
+      return [...ALL_SYNCABLE_FIELDS];
+    }
+
+    const allowed: Set<string> = new Set(ALL_SYNCABLE_FIELDS);
+    for (const field of fields) {
+      if (!allowed.has(field)) {
+        throw new BadDataException(
+          `Field "${field}" is not syncable from a monitor template`,
+        );
+      }
+    }
+    return fields as Array<SyncableTemplateField>;
+  }
+
+  private buildUpdateData(
+    template: Model,
+    fields: Array<SyncableTemplateField>,
+  ): Partial<Monitor> {
+    const updateData: Partial<Monitor> = {};
+
+    for (const field of fields) {
+      const value: unknown = (template as unknown as Record<string, unknown>)[
+        field
+      ];
+      if (value === undefined) {
+        continue;
+      }
+      (updateData as unknown as Record<string, unknown>)[field] = value;
+    }
+
+    return updateData;
+  }
+
+  /**
+   * Push the template's current configuration onto every monitor that was
+   * created from it. Sync is intentionally explicit (button-triggered) so a
+   * config tweak doesn't silently re-deploy across the whole fleet.
+   *
+   * Pass `fields` to scope the sync — e.g. `["monitorSteps"]` to push only the
+   * criteria. If omitted, every syncable field is pushed.
+   */
+  @CaptureSpan()
+  public async syncLinkedMonitors(data: {
+    monitorTemplateId: ObjectID;
+    props: DatabaseCommonInteractionProps;
+    fields?: Array<string>;
+  }): Promise<SyncLinkedMonitorsResult> {
+    const fields: Array<SyncableTemplateField> = this.validateSyncableFields(
+      data.fields,
+    );
+
+    const template: Model | null = await this.findOneById({
+      id: data.monitorTemplateId,
+      select: {
+        _id: true,
+        projectId: true,
+        monitorSteps: true,
+        monitoringInterval: true,
+        minimumProbeAgreement: true,
+      },
+      props: data.props,
+    });
+
+    if (!template) {
+      throw new BadDataException("Monitor template not found");
+    }
+
+    if (!template.projectId) {
+      throw new BadDataException("Monitor template is missing projectId");
+    }
+
+    const totalLinkedMonitors: number = await this.countLinkedMonitors({
+      monitorTemplateId: template.id!,
+      projectId: template.projectId,
+    });
+
+    if (totalLinkedMonitors === 0) {
+      return {
+        totalLinkedMonitors: 0,
+        syncedMonitors: 0,
+      };
+    }
+
+    const updateData: Partial<Monitor> = this.buildUpdateData(template, fields);
+
+    if (Object.keys(updateData).length === 0) {
+      return {
+        totalLinkedMonitors,
+        syncedMonitors: 0,
+      };
+    }
+
+    const syncedMonitors: number = await MonitorService.updateBy({
+      query: {
+        monitorTemplateId: template.id!,
+        projectId: template.projectId,
+      },
+      data: updateData as any,
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: data.props,
+    });
+
+    return {
+      totalLinkedMonitors,
+      syncedMonitors,
+    };
+  }
+
+  /**
+   * Sync the template's current configuration onto a single monitor that was
+   * created from it. The monitor must be linked to this template — passing an
+   * arbitrary monitor ID is rejected so the endpoint can't be tricked into
+   * pushing config to an unrelated monitor.
+   *
+   * Pass `fields` to scope the sync; if omitted, every syncable field is
+   * pushed.
+   */
+  @CaptureSpan()
+  public async syncToMonitor(data: {
+    monitorTemplateId: ObjectID;
+    monitorId: ObjectID;
+    props: DatabaseCommonInteractionProps;
+    fields?: Array<string>;
+  }): Promise<void> {
+    const fields: Array<SyncableTemplateField> = this.validateSyncableFields(
+      data.fields,
+    );
+
+    const template: Model | null = await this.findOneById({
+      id: data.monitorTemplateId,
+      select: {
+        _id: true,
+        projectId: true,
+        monitorSteps: true,
+        monitoringInterval: true,
+        minimumProbeAgreement: true,
+      },
+      props: data.props,
+    });
+
+    if (!template) {
+      throw new BadDataException("Monitor template not found");
+    }
+
+    if (!template.projectId) {
+      throw new BadDataException("Monitor template is missing projectId");
+    }
+
+    const monitor: Monitor | null = await MonitorService.findOneById({
+      id: data.monitorId,
+      select: {
+        _id: true,
+        projectId: true,
+        monitorTemplateId: true,
+      },
+      props: { isRoot: true },
+    });
+
+    if (!monitor) {
+      throw new BadDataException("Monitor not found");
+    }
+
+    if (
+      !monitor.monitorTemplateId ||
+      monitor.monitorTemplateId.toString() !== template.id!.toString()
+    ) {
+      throw new BadDataException("Monitor is not linked to this template");
+    }
+
+    if (
+      !monitor.projectId ||
+      monitor.projectId.toString() !== template.projectId.toString()
+    ) {
+      throw new BadDataException(
+        "Monitor and template belong to different projects",
+      );
+    }
+
+    const updateData: Partial<Monitor> = this.buildUpdateData(template, fields);
+
+    if (Object.keys(updateData).length === 0) {
+      return;
+    }
+
+    await MonitorService.updateOneById({
+      id: data.monitorId,
+      data: updateData as any,
+      props: data.props,
+    });
+  }
+
+  /**
+   * Link an existing monitor to this template. The monitor must be in the same
+   * project AND have the same monitorType as the template — anything else is
+   * rejected, so a user can't (e.g.) link an API monitor to a Server-monitor
+   * template and then sync incompatible criteria onto it.
+   */
+  @CaptureSpan()
+  public async linkMonitor(data: {
+    monitorTemplateId: ObjectID;
+    monitorId: ObjectID;
+    props: DatabaseCommonInteractionProps;
+  }): Promise<void> {
+    const template: Model | null = await this.findOneById({
+      id: data.monitorTemplateId,
+      select: {
+        _id: true,
+        projectId: true,
+        monitorType: true,
+      },
+      props: data.props,
+    });
+
+    if (!template) {
+      throw new BadDataException("Monitor template not found");
+    }
+    if (!template.projectId) {
+      throw new BadDataException("Monitor template is missing projectId");
+    }
+    if (!template.monitorType) {
+      throw new BadDataException("Monitor template is missing monitorType");
+    }
+
+    const monitor: Monitor | null = await MonitorService.findOneById({
+      id: data.monitorId,
+      select: {
+        _id: true,
+        projectId: true,
+        monitorType: true,
+      },
+      props: data.props,
+    });
+
+    if (!monitor) {
+      throw new BadDataException("Monitor not found");
+    }
+    if (
+      !monitor.projectId ||
+      monitor.projectId.toString() !== template.projectId.toString()
+    ) {
+      throw new BadDataException(
+        "Monitor and template belong to different projects",
+      );
+    }
+    if (monitor.monitorType !== template.monitorType) {
+      throw new BadDataException(
+        `Monitor type "${monitor.monitorType}" does not match template type "${template.monitorType}"`,
+      );
+    }
+
+    await MonitorService.updateOneById({
+      id: data.monitorId,
+      data: {
+        monitorTemplateId: template.id!,
+      } as any,
+      props: data.props,
+    });
+  }
+
+  /**
+   * Detach a monitor from this template. The monitor must currently be linked
+   * to *this* template — passing a monitor linked elsewhere (or unlinked) is
+   * rejected so a stale UI can't accidentally clear someone else's link.
+   */
+  @CaptureSpan()
+  public async unlinkMonitor(data: {
+    monitorTemplateId: ObjectID;
+    monitorId: ObjectID;
+    props: DatabaseCommonInteractionProps;
+  }): Promise<void> {
+    const monitor: Monitor | null = await MonitorService.findOneById({
+      id: data.monitorId,
+      select: {
+        _id: true,
+        monitorTemplateId: true,
+      },
+      props: data.props,
+    });
+
+    if (!monitor) {
+      throw new BadDataException("Monitor not found");
+    }
+    if (
+      !monitor.monitorTemplateId ||
+      monitor.monitorTemplateId.toString() !== data.monitorTemplateId.toString()
+    ) {
+      throw new BadDataException("Monitor is not linked to this template");
+    }
+
+    await MonitorService.updateOneById({
+      id: data.monitorId,
+      data: {
+        monitorTemplateId: null,
+      } as any,
+      props: data.props,
+    });
+  }
 }
 export default new Service();

package/Types/Dashboard/DashboardComponentType.ts

@@ -9,6 +9,19 @@ enum DashboardComponentType {
   IncidentList = `IncidentList`,
   AlertList = `AlertList`,
   MonitorList = `MonitorList`,
+  KubernetesPodList = `KubernetesPodList`,
+  KubernetesNodeList = `KubernetesNodeList`,
+  KubernetesNamespaceList = `KubernetesNamespaceList`,
+  KubernetesDeploymentList = `KubernetesDeploymentList`,
+  KubernetesStatefulSetList = `KubernetesStatefulSetList`,
+  KubernetesDaemonSetList = `KubernetesDaemonSetList`,
+  KubernetesJobList = `KubernetesJobList`,
+  KubernetesCronJobList = `KubernetesCronJobList`,
+  DockerHostList = `DockerHostList`,
+  DockerContainerList = `DockerContainerList`,
+  DockerImageList = `DockerImageList`,
+  DockerNetworkList = `DockerNetworkList`,
+  DockerVolumeList = `DockerVolumeList`,
 }
 
 export default DashboardComponentType;