@oneuptime/common 14.0.3 → 14.0.6

package/Server/Services/DatabaseService.ts

@@ -4015,17 +4015,23 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
     /*
      * The lock is taken by the sub-SELECT and inherited by the UPDATE within
      * the same implicit transaction, so the outer write never blocks either.
-     * RETURNING is how the affected-row count comes back: TypeORM's `query()`
-     * surfaces the driver's rows and a bare UPDATE returns none, so without it
-     * a skipped write is indistinguishable from an applied one.
+     *
+     * The UPDATE sits in a CTE so the statement is a SELECT of the rows it
+     * wrote. TypeORM's postgres `query()` answers a top-level UPDATE with
+     * `[rows, rowCount]` - an array of length 2 whether or not anything was
+     * written - so a bare `UPDATE ... RETURNING` made every skipped write
+     * read as applied. A SELECT comes back as its rows: one when the row
+     * was written, none when it was locked or no longer exists.
      */
-    const sql: string = `UPDATE "${metadata.tableName}" SET ${setClauses.join(
-      ", ",
-    )} WHERE "${primaryColumnName}" IN (SELECT "${primaryColumnName}" FROM "${
+    const sql: string = `WITH "updated" AS (UPDATE "${
       metadata.tableName
-    }" WHERE "${primaryColumnName}" = $${
+    }" SET ${setClauses.join(", ")} WHERE "${primaryColumnName}" IN (SELECT "${
+      primaryColumnName
+    }" FROM "${metadata.tableName}" WHERE "${primaryColumnName}" = $${
       params.length
-    } FOR UPDATE SKIP LOCKED) RETURNING "${primaryColumnName}"`;
+    } FOR UPDATE SKIP LOCKED) RETURNING "${primaryColumnName}") SELECT "${
+      primaryColumnName
+    }" FROM "updated"`;
 
     const result: unknown = await repository.manager.query(sql, params);
 

package/Server/Services/DockerResourceService.ts

@@ -39,6 +39,19 @@ export interface ParsedDockerContainer {
   cpuPercent: number | null;
   memoryBytes: number | null;
   observedAt: Date;
+  /*
+   * The container labels the agent copies onto its metrics (Compose /
+   * Swarm / Testcontainers keys, see CONTAINER_CLASSIFIER_LABEL_KEYS):
+   * MERGED into the row's labels, never replacing what the inventory
+   * snapshot wrote. Null / omitted leaves the labels alone.
+   */
+  labels?: JSONObject | null | undefined;
+  /*
+   * When the container's current run started (metric time − container.uptime).
+   * Fills an empty resourceCreationTimestamp, and moves it forward when
+   * the container was restarted or recreated under the same name.
+   */
+  startedAt?: Date | null | undefined;
 }
 
 export interface ParsedDockerResource {
@@ -141,7 +154,7 @@ export class Service extends DatabaseService<Model> {
 
       for (const c of chunk) {
         valueFragments.push(
-          `($${p++}, $${p++}, $${p++}, $${p++}, $${p++}, $${p++}, $${p++}, $${p++}::numeric, $${p++}::bigint, $${p++}::timestamptz, $${p++}::timestamptz, $${p++})`,
+          `($${p++}, $${p++}, $${p++}, $${p++}, $${p++}, $${p++}, $${p++}, $${p++}::numeric, $${p++}::bigint, $${p++}::timestamptz, $${p++}::timestamptz, $${p++}, $${p++}::jsonb, $${p++}::timestamptz)`,
         );
         params.push(
           data.projectId.toString(),
@@ -160,15 +173,27 @@ export class Service extends DatabaseService<Model> {
           c.observedAt,
           c.observedAt,
           0, // version (BaseModel @VersionColumn)
+          c.labels && Object.keys(c.labels).length > 0
+            ? JSON.stringify(c.labels)
+            : null,
+          c.startedAt || null,
         );
       }
 
+      /*
+       * The same container name with a different id is a recreated
+       * container: its labels and start time replace the old ones. Else
+       * the metric labels are merged into whatever the inventory wrote,
+       * and the start time only moves forward (a restart) — by more than
+       * a minute, so clock jitter between scrapes never rewrites it.
+       */
       const sql: string = `
         INSERT INTO "DockerResource" (
           "projectId", "dockerHostId", "kind", "name",
           "containerId", "imageName", "state",
           "latestCpuPercent", "latestMemoryBytes",
-          "metricsUpdatedAt", "lastSeenAt", "version"
+          "metricsUpdatedAt", "lastSeenAt", "version",
+          "labels", "resourceCreationTimestamp"
         )
         VALUES ${valueFragments.join(", ")}
         ON CONFLICT ("projectId", "dockerHostId", "kind", "name")
@@ -180,6 +205,22 @@ export class Service extends DatabaseService<Model> {
           "latestMemoryBytes" = COALESCE(EXCLUDED."latestMemoryBytes", "DockerResource"."latestMemoryBytes"),
           "metricsUpdatedAt" = EXCLUDED."metricsUpdatedAt",
           "lastSeenAt" = EXCLUDED."lastSeenAt",
+          "labels" = CASE
+            WHEN EXCLUDED."labels" IS NULL THEN "DockerResource"."labels"
+            WHEN lower(left(EXCLUDED."containerId", 12)) <> lower(left("DockerResource"."containerId", 12))
+              THEN EXCLUDED."labels"
+            WHEN jsonb_typeof("DockerResource"."labels") = 'object'
+              THEN "DockerResource"."labels" || EXCLUDED."labels"
+            ELSE EXCLUDED."labels"
+          END,
+          "resourceCreationTimestamp" = CASE
+            WHEN EXCLUDED."resourceCreationTimestamp" IS NULL THEN "DockerResource"."resourceCreationTimestamp"
+            WHEN "DockerResource"."resourceCreationTimestamp" IS NULL
+              OR lower(left(EXCLUDED."containerId", 12)) <> lower(left("DockerResource"."containerId", 12))
+              OR EXCLUDED."resourceCreationTimestamp" > "DockerResource"."resourceCreationTimestamp" + interval '1 minute'
+              THEN EXCLUDED."resourceCreationTimestamp"
+            ELSE "DockerResource"."resourceCreationTimestamp"
+          END,
           "updatedAt" = now()
         WHERE EXCLUDED."lastSeenAt" >= "DockerResource"."lastSeenAt"
       `;

package/Server/Services/IncidentReminderRuleService.ts

@@ -101,10 +101,34 @@ export class Service extends DatabaseService<Model> {
     return onDelete;
   }
 
+  /*
+   * Re-matches the reminder rule for every open incident in the project and
+   * rewrites its nextReminderNotificationAt.
+   *
+   * Without options that is one read of at most LIMIT_MAX open incidents, and
+   * it must stay one: the rule create, update and delete hooks run it inside
+   * the API request.
+   *
+   * `onlyWithoutNextReminder` narrows that to open incidents with no reminder
+   * scheduled at all, and reads every one of them, in `_id`-ordered pages of
+   * LIMIT_MAX. It exists for backfills (see the
+   * ScheduleRemindersMissedByReminderRuleLookup data migration), which run in a
+   * worker rather than a request and must reach every such incident of the
+   * project, however many there are. The pages are cursored by `_id`, not
+   * offset, because refreshing an incident can take it out of the set being
+   * paged. An incident that already has a timestamp is left alone, because
+   * re-scheduling it would push a reminder that is due, or overdue, one full
+   * interval later.
+   */
   @CaptureSpan()
   public async refreshSchedulesForOpenIncidents(
     projectId: ObjectID,
+    options?: { onlyWithoutNextReminder?: boolean | undefined } | undefined,
   ): Promise<void> {
+    const onlyWithoutNextReminder: boolean = Boolean(
+      options?.onlyWithoutNextReminder,
+    );
+
     try {
       const unresolvedStates: Array<IncidentState> =
         await IncidentStateService.findBy({
@@ -132,33 +156,51 @@ export class Service extends DatabaseService<Model> {
         return;
       }
 
-      const openIncidents: Array<Incident> = await IncidentService.findBy({
-        query: {
+      let afterId: ObjectID | null = null;
+
+      while (true) {
+        const openIncidents: Array<Incident> = await this.findOpenIncidents({
           projectId: projectId,
-          currentIncidentStateId: QueryHelper.any(unresolvedStateIds),
-        },
-        select: {
-          _id: true,
-        },
-        limit: LIMIT_MAX,
-        skip: 0,
-        props: {
-          isRoot: true,
-        },
-      });
+          unresolvedStateIds: unresolvedStateIds,
+          onlyWithoutNextReminder: onlyWithoutNextReminder,
+          afterId: afterId,
+        });
 
-      for (const incident of openIncidents) {
-        try {
-          await IncidentService.refreshReminderSchedule({
-            incidentId: incident.id!,
-            projectId: projectId,
-          });
-        } catch (error) {
-          logger.error(
-            `Failed to refresh reminder schedule for incident ${incident.id}: ${error}`,
-            { projectId: projectId?.toString() } as LogAttributes,
+        for (const incident of openIncidents) {
+          try {
+            await IncidentService.refreshReminderSchedule({
+              incidentId: incident.id!,
+              projectId: projectId,
+            });
+          } catch (error) {
+            logger.error(
+              `Failed to refresh reminder schedule for incident ${incident.id}: ${error}`,
+              { projectId: projectId?.toString() } as LogAttributes,
+            );
+          }
+        }
+
+        // Without the option, the one read above is all there is.
+        if (!onlyWithoutNextReminder || openIncidents.length < LIMIT_MAX) {
+          return;
+        }
+
+        const lastId: ObjectID | null =
+          openIncidents[openIncidents.length - 1]!.id;
+
+        if (!lastId || (afterId && lastId.toString() <= afterId.toString())) {
+          /*
+           * A full page whose last row does not move the cursor forward
+           * would be read again forever. Not reachable with `_id ASC` and a
+           * `> afterId` filter; guarded so a broken sort cannot hang the
+           * backfill.
+           */
+          throw new Error(
+            "the open incident page did not advance its _id cursor",
           );
         }
+
+        afterId = lastId;
       }
     } catch (error) {
       logger.error(
@@ -168,6 +210,44 @@ export class Service extends DatabaseService<Model> {
     }
   }
 
+  /*
+   * One read of the project's open incidents: those whose current state is one
+   * of `unresolvedStateIds`. Both paths of refreshSchedulesForOpenIncidents
+   * read through here, so what "open" means is written once.
+   *
+   * With `onlyWithoutNextReminder`, only those with no reminder scheduled,
+   * `_id` ascending and after `afterId` when there is one. Without it, no
+   * cursor and the default order: the read the rule hooks have always made.
+   */
+  private async findOpenIncidents(data: {
+    projectId: ObjectID;
+    unresolvedStateIds: Array<ObjectID>;
+    onlyWithoutNextReminder: boolean;
+    afterId: ObjectID | null;
+  }): Promise<Array<Incident>> {
+    return await IncidentService.findBy({
+      query: {
+        projectId: data.projectId,
+        currentIncidentStateId: QueryHelper.any(data.unresolvedStateIds),
+        ...(data.onlyWithoutNextReminder
+          ? { nextReminderNotificationAt: QueryHelper.isNull() }
+          : {}),
+        ...(data.afterId ? { _id: QueryHelper.greaterThan(data.afterId) } : {}),
+      },
+      select: {
+        _id: true,
+      },
+      ...(data.onlyWithoutNextReminder
+        ? { sort: { _id: SortOrder.Ascending } }
+        : {}),
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
   @CaptureSpan()
   public async findMatchingRule(data: {
     projectId: ObjectID;

package/Server/Services/Index.ts

@@ -106,6 +106,12 @@ import VMwareVCenterOwnerRuleService from "./VMwareVCenterOwnerRuleService";
 import VMwareVCenterOwnerTeamService from "./VMwareVCenterOwnerTeamService";
 import VMwareVCenterOwnerUserService from "./VMwareVCenterOwnerUserService";
 import CephClusterOwnerUserService from "./CephClusterOwnerUserService";
+import DatabaseServerService from "./DatabaseServerService";
+import DatabaseServerEndpointService from "./DatabaseServerEndpointService";
+import DatabaseServerLabelRuleService from "./DatabaseServerLabelRuleService";
+import DatabaseServerOwnerRuleService from "./DatabaseServerOwnerRuleService";
+import DatabaseServerOwnerTeamService from "./DatabaseServerOwnerTeamService";
+import DatabaseServerOwnerUserService from "./DatabaseServerOwnerUserService";
 import LlmProviderService from "./LlmProviderService";
 import DataSourceService from "./DataSourceService";
 import AuditLogService from "./AuditLogService";
@@ -150,6 +156,7 @@ import KubernetesClusterFeedService from "./KubernetesClusterFeedService";
 import DockerHostFeedService from "./DockerHostFeedService";
 import DockerSwarmClusterFeedService from "./DockerSwarmClusterFeedService";
 import CephClusterFeedService from "./CephClusterFeedService";
+import DatabaseServerFeedService from "./DatabaseServerFeedService";
 import PodmanHostFeedService from "./PodmanHostFeedService";
 import ProxmoxClusterFeedService from "./ProxmoxClusterFeedService";
 import VMwareVCenterFeedService from "./VMwareVCenterFeedService";
@@ -291,6 +298,7 @@ import UserOnCallLogService from "./UserOnCallLogService";
 import UserOnCallLogTimelineService from "./UserOnCallLogTimelineService";
 import UserService from "./UserService";
 import UserSessionService from "./UserSessionService";
+import UserProjectSsoConsentService from "./UserProjectSsoConsentService";
 import UserTotpAuthService from "./UserTotpAuthService";
 import UserTwoFactorBackupCodeService from "./UserTwoFactorBackupCodeService";
 import UserWebAuthnService from "./UserWebAuthnService";
@@ -573,6 +581,12 @@ const services: Array<BaseService> = [
   VMwareVCenterOwnerRuleService,
   VMwareVCenterOwnerTeamService,
   VMwareVCenterOwnerUserService,
+  DatabaseServerService,
+  DatabaseServerEndpointService,
+  DatabaseServerLabelRuleService,
+  DatabaseServerOwnerRuleService,
+  DatabaseServerOwnerTeamService,
+  DatabaseServerOwnerUserService,
   LlmProviderService,
   DataSourceService,
 
@@ -600,6 +614,7 @@ const services: Array<BaseService> = [
   DockerHostFeedService,
   DockerSwarmClusterFeedService,
   CephClusterFeedService,
+  DatabaseServerFeedService,
   PodmanHostFeedService,
   ProxmoxClusterFeedService,
   VMwareVCenterFeedService,
@@ -691,6 +706,7 @@ const services: Array<BaseService> = [
 
   UserService,
   UserSessionService,
+  UserProjectSsoConsentService,
   UserCallService,
   UserEmailService,
   UserNotificationRuleService,

package/Server/Services/InventoryItemService.ts

@@ -31,6 +31,11 @@ import {
   shouldWarnEntityBudgetOnce,
 } from "../Utils/Telemetry/EntityRegistry";
 
+// A database node's port, as its calls named it (deriveDatabaseDisplayName).
+const PORT_REGEX: RegExp = /^\d{1,5}$/;
+// A bare IPv6 address - bracketed before a port.
+const IPV6_LITERAL_REGEX: RegExp = /^[0-9a-f:.]+$/i;
+
 export class InventoryItemService extends DatabaseService<Model> {
   public constructor() {
     super(Model);
@@ -427,6 +432,39 @@ export class InventoryItemService extends DatabaseService<Model> {
       }
     }
 
+    /*
+     * A database dependency node named by the old rule - its bare namespace,
+     * "orders" for every Postgres a project calls - is renamed to
+     * "<namespace> @ <server>" the next time it is seen. Same guard as above:
+     * only a name this service generated is replaced, never one a person
+     * typed, and a later sighting that cannot name the port does not undo a
+     * name that has it.
+     */
+    if (entity.entityType === EntityType.Database) {
+      const desiredDisplayName: string =
+        InventoryItemService.deriveDatabaseDisplayName(entity).substring(
+          0,
+          ColumnLength.ShortText,
+        );
+      const existingDisplayName: string = existing.displayName || "";
+      const generatedBefore: Array<string> = [
+        InventoryItemService.deriveLegacyDatabaseDisplayName(entity),
+        InventoryItemService.deriveDatabaseDisplayName(entity, {
+          withPort: false,
+        }),
+      ].map((name: string): string => {
+        return name.substring(0, ColumnLength.ShortText);
+      });
+
+      if (
+        desiredDisplayName &&
+        existingDisplayName !== desiredDisplayName &&
+        (!existingDisplayName || generatedBefore.includes(existingDisplayName))
+      ) {
+        update.displayName = desiredDisplayName;
+      }
+    }
+
     const incoming: Record<string, string> = entity.descriptiveAttributes || {};
     if (Object.keys(incoming).length > 0) {
       const current: Record<string, unknown> =
@@ -498,6 +536,13 @@ export class InventoryItemService extends DatabaseService<Model> {
       }
     }
 
+    if (entity.entityType === EntityType.Database) {
+      const databaseName: string = this.deriveDatabaseDisplayName(entity);
+      if (databaseName) {
+        return databaseName;
+      }
+    }
+
     for (const key of this.dependencyDisplayNameOrderByType[
       entity.entityType
     ] || []) {
@@ -509,13 +554,76 @@ export class InventoryItemService extends DatabaseService<Model> {
     return this.deriveFallbackDisplayName(entity);
   }
 
+  /*
+   * A database dependency node is named after the logical database AND the
+   * server it lives on: "<db.namespace> @ <host[:port]>". The namespace alone
+   * ("orders") is shared by every copy of an application's schema - an e2e
+   * project showed ten different PostgreSQL servers all named "orders" on
+   * the Service Map and in Inventory. The host is the node's identifying
+   * `server.address`; the port is the descriptive `server.port` its calls
+   * named (left off when they named none, or several). Only the name
+   * changes: the node's identity (engine, host, namespace) does not.
+   * Without a namespace it is the server alone, without a host the
+   * namespace, and with neither the engine. '' when nothing names it.
+   */
+  public static deriveDatabaseDisplayName(
+    entity: ExtractedEntity,
+    options?: { withPort?: boolean | undefined },
+  ): string {
+    const id: Record<string, string> = entity.identifyingAttributes || {};
+    const descriptive: Record<string, string> =
+      entity.descriptiveAttributes || {};
+
+    const namespace: string = (id["db.namespace"] || "").trim();
+    const host: string = (id["server.address"] || "").trim();
+    const port: string = (descriptive["server.port"] || "").trim();
+
+    let server: string = host;
+    if (host && options?.withPort !== false && PORT_REGEX.test(port)) {
+      if (!host.includes(":")) {
+        server = `${host}:${port}`;
+      } else if (IPV6_LITERAL_REGEX.test(host)) {
+        // A bare IPv6 address takes brackets before a port.
+        server = `[${host}]:${port}`;
+      }
+      // Anything else with a colon (a host list) already names its ports.
+    }
+
+    if (namespace && server) {
+      return `${namespace} @ ${server}`;
+    }
+
+    return server || namespace || (id["db.system.name"] || "").trim();
+  }
+
+  /*
+   * What deriveDisplayName named a database node before it named the server
+   * too: the first of namespace, host, engine. Only a row still carrying
+   * this (or the port-less new name) is renamed - see buildDescriptiveUpdate.
+   */
+  private static deriveLegacyDatabaseDisplayName(
+    entity: ExtractedEntity,
+  ): string {
+    const id: Record<string, string> = entity.identifyingAttributes || {};
+
+    for (const key of this.dependencyDisplayNameOrderByType[
+      EntityType.Database
+    ] || []) {
+      if (id[key]) {
+        return id[key]!;
+      }
+    }
+
+    return this.deriveFallbackDisplayName(entity);
+  }
+
   /*
    * Dependency endpoints have composite identities in which the most
-   * recognisable part is not a `*.name` key: a database reads best as its
-   * namespace ("orders"), then the host it lives on, and only as a last
-   * resort as its engine ("postgresql" is shared by every Postgres a project
-   * calls). Remote endpoints read best as the service name their callers gave
-   * them, then their host.
+   * recognisable part is not a `*.name` key. A database is named by
+   * deriveDatabaseDisplayName; its order here is the old rule (namespace,
+   * then host, then engine), which deriveLegacyDatabaseDisplayName reads to
+   * recognise the names it generated. Remote endpoints read best as the
+   * service name their callers gave them, then their host.
    */
   private static readonly dependencyDisplayNameOrderByType: Partial<
     Record<EntityType, Array<string>>

package/Server/Services/IoTDeviceService.ts

@@ -78,6 +78,123 @@ const UPSERT_COLUMNS: Array<string> = [
   "version",
 ];
 
+/*
+ * One entry per column of the `FROM (VALUES ...) AS v(...)` source in
+ * bulkUpdateLatestMetrics(). The placeholder tuple, the alias list, the
+ * bound params and the SET clause are all generated from this table, so
+ * they cannot drift apart: a hand-written tuple once carried 9
+ * placeholders against 10 aliases and 10 params, and Postgres rejected
+ * every mirror write (GitHub #3998).
+ *
+ * mirrorColumn: the IoTDevice column the value is COALESCEd into, or
+ * null for the join keys and observedAt, which the statement uses
+ * directly.
+ */
+export interface LatestMetricColumn {
+  alias: string;
+  cast: string | null;
+  mirrorColumn: string | null;
+  value: (metric: IoTDeviceLatestMetric) => unknown;
+}
+
+const nullableNumber: (value: number | null | undefined) => number | null = (
+  value: number | null | undefined,
+): number | null => {
+  return value !== null && value !== undefined ? value : null;
+};
+
+// bigint params go over the wire as integer strings: a JS number past 2^53 loses precision.
+const nullableBigInt: (value: number | null | undefined) => string | null = (
+  value: number | null | undefined,
+): string | null => {
+  return value !== null && value !== undefined
+    ? Math.trunc(value).toString()
+    : null;
+};
+
+export const LATEST_METRIC_COLUMNS: ReadonlyArray<LatestMetricColumn> = [
+  {
+    alias: "kind",
+    cast: null,
+    mirrorColumn: null,
+    value: (m: IoTDeviceLatestMetric): unknown => {
+      return m.kind;
+    },
+  },
+  {
+    alias: "externalId",
+    cast: null,
+    mirrorColumn: null,
+    value: (m: IoTDeviceLatestMetric): unknown => {
+      return m.externalId;
+    },
+  },
+  {
+    alias: "cpu",
+    cast: "numeric",
+    mirrorColumn: "latestCpuPercent",
+    value: (m: IoTDeviceLatestMetric): unknown => {
+      return nullableNumber(m.cpuPercent);
+    },
+  },
+  {
+    alias: "mem",
+    cast: "bigint",
+    mirrorColumn: "latestMemoryBytes",
+    value: (m: IoTDeviceLatestMetric): unknown => {
+      return nullableBigInt(m.memoryBytes);
+    },
+  },
+  {
+    alias: "maxMem",
+    cast: "bigint",
+    mirrorColumn: "maxMemoryBytes",
+    value: (m: IoTDeviceLatestMetric): unknown => {
+      return nullableBigInt(m.maxMemoryBytes);
+    },
+  },
+  {
+    alias: "memPct",
+    cast: "numeric",
+    mirrorColumn: "latestMemoryPercent",
+    value: (m: IoTDeviceLatestMetric): unknown => {
+      return nullableNumber(m.memoryPercent);
+    },
+  },
+  {
+    alias: "battery",
+    cast: "numeric",
+    mirrorColumn: "latestBatteryPercent",
+    value: (m: IoTDeviceLatestMetric): unknown => {
+      return nullableNumber(m.batteryPercent);
+    },
+  },
+  {
+    alias: "signal",
+    cast: "numeric",
+    mirrorColumn: "latestSignalStrengthDbm",
+    value: (m: IoTDeviceLatestMetric): unknown => {
+      return nullableNumber(m.signalStrengthDbm);
+    },
+  },
+  {
+    alias: "temp",
+    cast: "numeric",
+    mirrorColumn: "latestTemperatureCelsius",
+    value: (m: IoTDeviceLatestMetric): unknown => {
+      return nullableNumber(m.temperatureCelsius);
+    },
+  },
+  {
+    alias: "observedAt",
+    cast: "timestamptz",
+    mirrorColumn: null,
+    value: (m: IoTDeviceLatestMetric): unknown => {
+      return m.observedAt;
+    },
+  },
+];
+
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
@@ -260,6 +377,22 @@ export class Service extends DatabaseService<Model> {
       return;
     }
 
+    const aliases: string = LATEST_METRIC_COLUMNS.map(
+      (column: LatestMetricColumn) => {
+        return `"${column.alias}"`;
+      },
+    ).join(", ");
+
+    const assignments: string = LATEST_METRIC_COLUMNS.filter(
+      (column: LatestMetricColumn) => {
+        return column.mirrorColumn !== null;
+      },
+    )
+      .map((column: LatestMetricColumn) => {
+        return `"${column.mirrorColumn}" = COALESCE(v."${column.alias}", p."${column.mirrorColumn}"),`;
+      })
+      .join("\n          ");
+
     for (let i: number = 0; i < metrics.length; i += UPSERT_BATCH_SIZE) {
       const chunk: Array<IoTDeviceLatestMetric> = metrics.slice(
         i,
@@ -274,51 +407,26 @@ export class Service extends DatabaseService<Model> {
       let paramIndex: number = 3;
 
       for (const m of chunk) {
-        valueFragments.push(
-          `($${paramIndex++}, $${paramIndex++}, $${paramIndex++}::numeric, $${paramIndex++}::bigint, $${paramIndex++}::bigint, $${paramIndex++}::numeric, $${paramIndex++}::numeric, $${paramIndex++}::numeric, $${paramIndex++}::timestamptz)`,
-        );
-        params.push(
-          m.kind,
-          m.externalId,
-          m.cpuPercent !== null && m.cpuPercent !== undefined
-            ? m.cpuPercent
-            : null,
-          m.memoryBytes !== null && m.memoryBytes !== undefined
-            ? Math.trunc(m.memoryBytes).toString()
-            : null,
-          m.maxMemoryBytes !== null && m.maxMemoryBytes !== undefined
-            ? Math.trunc(m.maxMemoryBytes).toString()
-            : null,
-          m.memoryPercent !== null && m.memoryPercent !== undefined
-            ? m.memoryPercent
-            : null,
-          m.batteryPercent !== null && m.batteryPercent !== undefined
-            ? m.batteryPercent
-            : null,
-          m.signalStrengthDbm !== null && m.signalStrengthDbm !== undefined
-            ? m.signalStrengthDbm
-            : null,
-          m.temperatureCelsius !== null && m.temperatureCelsius !== undefined
-            ? m.temperatureCelsius
-            : null,
-          m.observedAt,
-        );
+        const placeholders: Array<string> = [];
+        for (const column of LATEST_METRIC_COLUMNS) {
+          placeholders.push(
+            column.cast
+              ? `$${paramIndex++}::${column.cast}`
+              : `$${paramIndex++}`,
+          );
+          params.push(column.value(m));
+        }
+        valueFragments.push(`(${placeholders.join(", ")})`);
       }
 
       const sql: string = `
         UPDATE "IoTDevice" AS p
         SET
-          "latestCpuPercent" = COALESCE(v."cpu", p."latestCpuPercent"),
-          "latestMemoryBytes" = COALESCE(v."mem", p."latestMemoryBytes"),
-          "maxMemoryBytes" = COALESCE(v."maxMem", p."maxMemoryBytes"),
-          "latestMemoryPercent" = COALESCE(v."memPct", p."latestMemoryPercent"),
-          "latestBatteryPercent" = COALESCE(v."battery", p."latestBatteryPercent"),
-          "latestSignalStrengthDbm" = COALESCE(v."signal", p."latestSignalStrengthDbm"),
-          "latestTemperatureCelsius" = COALESCE(v."temp", p."latestTemperatureCelsius"),
+          ${assignments}
           "metricsUpdatedAt" = v."observedAt",
           "updatedAt" = now()
         FROM (VALUES ${valueFragments.join(", ")})
-          AS v("kind", "externalId", "cpu", "mem", "maxMem", "memPct", "battery", "signal", "temp", "observedAt")
+          AS v(${aliases})
         WHERE
           p."projectId" = $1
           AND p."iotFleetId" = $2