@oneuptime/common 11.3.20 → 11.3.21

package/Server/EnvironmentConfig.ts

@@ -543,6 +543,15 @@ export const StatusPageApiInternalUrl: URL = URL.fromString(
   AppApiClientUrl.toString(),
 ).addRoute(new Route("/status-page"));
 
+/*
+ *Internal URL for server-to-server communication with the Dashboard API.
+ *Note: The internal path is /api/dashboard (not /public-dashboard-api) because
+ * /public-dashboard-api is the external route that Nginx rewrites to /api/dashboard
+ */
+export const DashboardApiInternalUrl: URL = URL.fromString(
+  AppApiClientUrl.toString(),
+).addRoute(new Route("/dashboard"));
+
 export const DashboardClientUrl: URL = new URL(
   HttpProtocol,
   Host,

package/Server/Infrastructure/Postgres/SchemaMigrations/1783226868418-AddEnterpriseLicenseInstance.ts

@@ -0,0 +1,47 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddEnterpriseLicenseInstance1783226868418
+  implements MigrationInterface
+{
+  public name = "AddEnterpriseLicenseInstance1783226868418";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "EnterpriseLicenseInstance" ("_id" uuid NOT NULL DEFAULT uuid_generate_v4(), "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "deletedAt" TIMESTAMP WITH TIME ZONE, "version" integer NOT NULL, "enterpriseLicenseId" uuid NOT NULL, "instanceId" character varying(100) NOT NULL, "host" character varying(100), "userCount" integer, "userEmailHashes" jsonb, "lastReportedAt" TIMESTAMP WITH TIME ZONE, CONSTRAINT "PK_af49c1c72bebf72915b9d38721d" PRIMARY KEY ("_id"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_743f3cfb5c7170f50de2159c3f" ON "EnterpriseLicenseInstance" ("enterpriseLicenseId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_25feed2a867b2a3d81d0633878" ON "EnterpriseLicenseInstance" ("instanceId") `,
+    );
+    await queryRunner.query(
+      `CREATE UNIQUE INDEX "IDX_4e293ff0c754f702657b1d3abf" ON "EnterpriseLicenseInstance" ("enterpriseLicenseId", "instanceId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" ADD "enterpriseLicenseInstances" jsonb`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "EnterpriseLicenseInstance" ADD CONSTRAINT "FK_743f3cfb5c7170f50de2159c3f8" FOREIGN KEY ("enterpriseLicenseId") REFERENCES "EnterpriseLicense"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "EnterpriseLicenseInstance" DROP CONSTRAINT "FK_743f3cfb5c7170f50de2159c3f8"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "GlobalConfig" DROP COLUMN "enterpriseLicenseInstances"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_4e293ff0c754f702657b1d3abf"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_25feed2a867b2a3d81d0633878"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_743f3cfb5c7170f50de2159c3f"`,
+    );
+    await queryRunner.query(`DROP TABLE "EnterpriseLicenseInstance"`);
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -404,6 +404,7 @@ import { AddIoTFleetAndDeviceTables1782900000000 } from "./1782900000000-AddIoTF
 import { AddIoTFleetActivityJoinTables1783000000000 } from "./1783000000000-AddIoTFleetActivityJoinTables";
 import { MigrationName1783010000000 } from "./1783010000000-MigrationName";
 import { AddInstanceIdToGlobalConfig1783161406136 } from "./1783161406136-AddInstanceIdToGlobalConfig";
+import { AddEnterpriseLicenseInstance1783226868418 } from "./1783226868418-AddEnterpriseLicenseInstance";
 
 export default [
   InitialMigration,
@@ -812,4 +813,5 @@ export default [
   AddIoTFleetActivityJoinTables1783000000000,
   MigrationName1783010000000,
   AddInstanceIdToGlobalConfig1783161406136,
+  AddEnterpriseLicenseInstance1783226868418,
 ];

package/Server/Services/EnterpriseLicenseInstanceService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import EnterpriseLicenseInstance from "../../Models/DatabaseModels/EnterpriseLicenseInstance";
+
+export class Service extends DatabaseService<EnterpriseLicenseInstance> {
+  public constructor() {
+    super(EnterpriseLicenseInstance);
+  }
+}
+
+export default new Service();

package/Server/Services/Index.ts

@@ -113,6 +113,7 @@ import GlobalSsoProjectService from "./GlobalSsoProjectService";
 import GlobalOidcProjectService from "./GlobalOidcProjectService";
 import PromoCodeService from "./PromoCodeService";
 import EnterpriseLicenseService from "./EnterpriseLicenseService";
+import EnterpriseLicenseInstanceService from "./EnterpriseLicenseInstanceService";
 import OpenSourceDeploymentService from "./OpenSourceDeploymentService";
 import ResellerPlanService from "./ResellerPlanService";
 import ResellerService from "./ResellerService";
@@ -251,6 +252,7 @@ const services: Array<BaseService> = [
   AcmeCertificateService,
   PromoCodeService,
   EnterpriseLicenseService,
+  EnterpriseLicenseInstanceService,
   OpenSourceDeploymentService,
 
   ResellerService,

package/Server/Services/IoTDeviceService.ts

@@ -1,8 +1,10 @@
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/IoTDevice";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import ColumnLength from "../../Types/Database/ColumnLength";
 import ObjectID from "../../Types/ObjectID";
 import OneUptimeDate from "../../Types/Date";
+import { clampIoTTimestamp } from "../Utils/Telemetry/IoTSnapshotScan";
 import logger from "../Utils/Logger";
 
 /*
@@ -57,6 +59,23 @@ export interface IoTInventorySummary {
 const UPSERT_BATCH_SIZE: number = 500;
 const STALE_DELETE_WARN_THRESHOLD: number = 100;
 
+/*
+ * The identity/text columns are ShortText (100 chars). A single value
+ * over the column limit fails the whole multi-row INSERT chunk it rides
+ * in — truncate per value instead so one malformed device can never
+ * drop the other rows of its chunk.
+ */
+function truncateShortText(value: string): string;
+function truncateShortText(value: string | null): string | null;
+function truncateShortText(value: string | null): string | null {
+  if (value === null) {
+    return value;
+  }
+  return value.length > ColumnLength.ShortText
+    ? value.substring(0, ColumnLength.ShortText)
+    : value;
+}
+
 /*
  * Column order used by bulkUpsert() and its generated parameter tuples.
  * Keep this and the INSERT column list in perfect sync.
@@ -103,9 +122,52 @@ export class Service extends DatabaseService<Model> {
       return;
     }
 
+    /*
+     * Sanitize before building chunks: ShortText columns truncate to
+     * the column limit (one over-long device.id must not fail the
+     * whole 500-row chunk), lastSeenAt clamps so a future-skewed
+     * device clock can't wedge the `>=` dominance guard, and rows that
+     * collide on the conflict target after truncation dedupe to the
+     * newest observation (two VALUES rows hitting the same conflict
+     * target would abort the statement).
+     */
+    const dedupedByIdentity: Map<string, ParsedIoTDevice> = new Map();
+    for (const r of data.devices) {
+      const externalId: string = truncateShortText(r.externalId);
+      if (!externalId) {
+        continue;
+      }
+      if (externalId !== r.externalId) {
+        logger.warn(
+          `IoTDevice externalId exceeds ${ColumnLength.ShortText} chars; truncated to "${externalId}" (fleet ${data.iotFleetId.toString()}).`,
+        );
+      }
+      const device: ParsedIoTDevice = {
+        ...r,
+        kind: truncateShortText(r.kind),
+        externalId,
+        name: truncateShortText(r.name),
+        deviceType: truncateShortText(r.deviceType),
+        firmwareVersion: truncateShortText(r.firmwareVersion),
+        lastSeenAt: clampIoTTimestamp(r.lastSeenAt),
+      };
+      const key: string = `${device.kind}|${device.externalId}`;
+      const existing: ParsedIoTDevice | undefined = dedupedByIdentity.get(key);
+      if (!existing || device.lastSeenAt >= existing.lastSeenAt) {
+        dedupedByIdentity.set(key, device);
+      }
+    }
+
+    const devices: Array<ParsedIoTDevice> = Array.from(
+      dedupedByIdentity.values(),
+    );
+    if (devices.length === 0) {
+      return;
+    }
+
     // Chunk to keep individual statement parameter counts reasonable.
-    for (let i: number = 0; i < data.devices.length; i += UPSERT_BATCH_SIZE) {
-      const chunk: Array<ParsedIoTDevice> = data.devices.slice(
+    for (let i: number = 0; i < devices.length; i += UPSERT_BATCH_SIZE) {
+      const chunk: Array<ParsedIoTDevice> = devices.slice(
         i,
         i + UPSERT_BATCH_SIZE,
       );
@@ -181,8 +243,41 @@ export class Service extends DatabaseService<Model> {
       return;
     }
 
-    for (let i: number = 0; i < data.metrics.length; i += UPSERT_BATCH_SIZE) {
-      const chunk: Array<IoTDeviceLatestMetric> = data.metrics.slice(
+    /*
+     * Same sanitation as bulkUpsert — and the identity truncation MUST
+     * match it, or the mirror UPDATE would silently miss the row the
+     * upsert just wrote under the truncated id. Dedupe keeps the UPDATE
+     * deterministic when two rows collapse onto one identity.
+     */
+    const dedupedByIdentity: Map<string, IoTDeviceLatestMetric> = new Map();
+    for (const m of data.metrics) {
+      const externalId: string = truncateShortText(m.externalId);
+      if (!externalId) {
+        continue;
+      }
+      const metric: IoTDeviceLatestMetric = {
+        ...m,
+        kind: truncateShortText(m.kind),
+        externalId,
+        observedAt: clampIoTTimestamp(m.observedAt),
+      };
+      const key: string = `${metric.kind}|${metric.externalId}`;
+      const existing: IoTDeviceLatestMetric | undefined =
+        dedupedByIdentity.get(key);
+      if (!existing || metric.observedAt >= existing.observedAt) {
+        dedupedByIdentity.set(key, metric);
+      }
+    }
+
+    const metrics: Array<IoTDeviceLatestMetric> = Array.from(
+      dedupedByIdentity.values(),
+    );
+    if (metrics.length === 0) {
+      return;
+    }
+
+    for (let i: number = 0; i < metrics.length; i += UPSERT_BATCH_SIZE) {
+      const chunk: Array<IoTDeviceLatestMetric> = metrics.slice(
         i,
         i + UPSERT_BATCH_SIZE,
       );

package/Server/Services/StatusPageService.ts

@@ -37,6 +37,7 @@ import User from "../../Models/DatabaseModels/User";
 import {
   AllowedStatusPageCountInFreePlan,
   IsBillingEnabled,
+  LetsEncryptAccountKey,
 } from "../EnvironmentConfig";
 import { PlanType } from "../../Types/Billing/SubscriptionPlan";
 import Recurring from "../../Types/Events/Recurring";
@@ -96,9 +97,9 @@ export class Service extends DatabaseService<StatusPage> {
    * Caches the resolved status page URL per statusPageId. `getStatusPageURL`
    * is called inside per-subscriber notification loops (see
    * `StatusPageSubscriberService`), where a single batch can fire N×
-   * Postgres lookups against `StatusPageDomain`. SSL-provisioned custom
-   * domains change rarely (provisioning takes minutes), so a 60s staleness
-   * window is acceptable. Callers that need stronger consistency can call
+   * Postgres lookups against `StatusPageDomain`. Usable custom domains
+   * change rarely (provisioning/verification takes minutes), so a 60s
+   * staleness window is acceptable. Callers that need stronger consistency can call
    * `clearStatusPageUrlCache` after writes to the underlying domain.
    */
   private statusPageUrlCache: InMemoryTTLCache<string> = new InMemoryTTLCache(
@@ -679,32 +680,107 @@ export class Service extends DatabaseService<StatusPage> {
     return monitorStatusTimelines;
   }
 
+  /*
+   * Picks the custom domain to use when linking to this status page from
+   * subscriber notifications (email/SMS/Slack/Teams/webhooks) and SSO
+   * redirects. A domain is usable when any of these holds, in order of
+   * preference:
+   * 1. `isSslProvisioned` — OneUptime ordered the certificate and confirmed
+   *    the domain serves HTTPS.
+   * 2. `isCustomCertificate` + `isCnameVerified` — the user uploaded their
+   *    own certificate (the SSL provisioning jobs skip these domains, so
+   *    `isSslProvisioned` never becomes true for them) and the CNAME check
+   *    confirmed the domain actually routes to this instance. CNAME alone
+   *    guards against certs uploaded before DNS is pointed.
+   * 3. `isCnameVerified`, but only when this instance has no Let's Encrypt
+   *    account key — self-hosted installs that terminate TLS at their own
+   *    proxy can never provision SSL, so CNAME verification is the
+   *    strongest available signal that the domain routes to this instance.
+   *    (With Let's Encrypt configured, a verified-but-unprovisioned domain
+   *    is just mid-provisioning and will be picked up by rule 1 shortly.)
+   * Without rules 2 and 3, such status pages fall back to the installation
+   * URL in every subscriber notification
+   * (https://github.com/OneUptime/oneuptime/issues/1951).
+   */
   @CaptureSpan()
-  public async getStatusPageURL(statusPageId: ObjectID): Promise<string> {
-    const cacheKey: string = statusPageId.toString();
-    const cached: string | undefined = this.statusPageUrlCache.get(cacheKey);
-    if (cached !== undefined) {
-      return cached;
-    }
-
-    const domain: StatusPageDomain | null =
-      await StatusPageDomainService.findOneBy({
+  public async getUsableCustomDomain(
+    statusPageId: ObjectID,
+  ): Promise<StatusPageDomain | null> {
+    const domains: Array<StatusPageDomain> =
+      await StatusPageDomainService.findBy({
         query: {
           statusPageId: statusPageId,
-          isSslProvisioned: true,
         },
         select: {
           fullDomain: true,
+          isSslProvisioned: true,
+          isCustomCertificate: true,
+          isCnameVerified: true,
         },
+        skip: 0,
+        limit: LIMIT_PER_PROJECT,
         props: {
           isRoot: true,
           ignoreHooks: true,
         },
       });
 
-    let statusPageURL: string = domain?.fullDomain
-      ? `https://${domain.fullDomain}`
-      : "";
+    const domainsWithFullDomain: Array<StatusPageDomain> = domains.filter(
+      (domain: StatusPageDomain) => {
+        return Boolean(domain.fullDomain);
+      },
+    );
+
+    return (
+      domainsWithFullDomain.find((domain: StatusPageDomain) => {
+        return domain.isSslProvisioned;
+      }) ||
+      domainsWithFullDomain.find((domain: StatusPageDomain) => {
+        return domain.isCustomCertificate && domain.isCnameVerified;
+      }) ||
+      (!LetsEncryptAccountKey
+        ? domainsWithFullDomain.find((domain: StatusPageDomain) => {
+            return domain.isCnameVerified;
+          })
+        : undefined) ||
+      null
+    );
+  }
+
+  /*
+   * SSL-provisioned and custom-certificate domains are known to serve
+   * HTTPS. A CNAME-verified-only domain (self-hosted instance behind the
+   * user's own proxy) follows the instance protocol instead — CNAME
+   * verification can succeed over plain HTTP, so an HTTP-only install
+   * gets http:// links that actually work.
+   */
+  private async getProtocolForCustomDomain(
+    domain: StatusPageDomain,
+  ): Promise<Protocol> {
+    if (domain.isSslProvisioned || domain.isCustomCertificate) {
+      return Protocol.HTTPS;
+    }
+
+    return DatabaseConfig.getHttpProtocol();
+  }
+
+  @CaptureSpan()
+  public async getStatusPageURL(statusPageId: ObjectID): Promise<string> {
+    const cacheKey: string = statusPageId.toString();
+    const cached: string | undefined = this.statusPageUrlCache.get(cacheKey);
+    if (cached !== undefined) {
+      return cached;
+    }
+
+    const domain: StatusPageDomain | null =
+      await this.getUsableCustomDomain(statusPageId);
+
+    let statusPageURL: string = "";
+
+    if (domain?.fullDomain) {
+      const protocol: Protocol = await this.getProtocolForCustomDomain(domain);
+      statusPageURL = `${protocol}${domain.fullDomain}`;
+    }
 
     if (!statusPageURL) {
       const host: Hostname = await DatabaseConfig.getHost();
@@ -724,39 +800,22 @@ export class Service extends DatabaseService<StatusPage> {
 
   @CaptureSpan()
   public async getStatusPageFirstURL(statusPageId: ObjectID): Promise<string> {
-    const domains: Array<StatusPageDomain> =
-      await StatusPageDomainService.findBy({
-        query: {
-          statusPageId: statusPageId,
-          isSslProvisioned: true,
-        },
-        select: {
-          fullDomain: true,
-        },
-        skip: 0,
-        limit: LIMIT_PER_PROJECT,
-        props: {
-          isRoot: true,
-          ignoreHooks: true,
-        },
-      });
-
-    let statusPageURL: string = "";
+    const domain: StatusPageDomain | null =
+      await this.getUsableCustomDomain(statusPageId);
 
-    if (domains.length === 0) {
-      const host: Hostname = await DatabaseConfig.getHost();
+    if (domain?.fullDomain) {
+      const protocol: Protocol = await this.getProtocolForCustomDomain(domain);
+      return `${protocol}${domain.fullDomain}`;
+    }
 
-      const httpProtocol: Protocol = await DatabaseConfig.getHttpProtocol();
+    const host: Hostname = await DatabaseConfig.getHost();
 
-      // 'https://local.oneuptime.com/status-page/40092fb5-cc33-4995-b532-b4e49c441c98'
-      statusPageURL = new URL(httpProtocol, host)
-        .addRoute("/status-page/" + statusPageId.toString())
-        .toString();
-    } else {
-      statusPageURL = domains[0]?.fullDomain || "";
-    }
+    const httpProtocol: Protocol = await DatabaseConfig.getHttpProtocol();
 
-    return statusPageURL;
+    // 'https://local.oneuptime.com/status-page/40092fb5-cc33-4995-b532-b4e49c441c98'
+    return new URL(httpProtocol, host)
+      .addRoute("/status-page/" + statusPageId.toString())
+      .toString();
   }
 
   @CaptureSpan()

package/Server/Utils/Monitor/Criteria/MetricMonitorCriteria.ts

@@ -3,6 +3,7 @@ import AggregatedResult from "../../../../Types/BaseDatabase/AggregatedResult";
 import MetricFormulaConfigData from "../../../../Types/Metrics/MetricFormulaConfigData";
 import MetricQueryConfigData from "../../../../Types/Metrics/MetricQueryConfigData";
 import MetricsAggregationType from "../../../../Types/Metrics/MetricsAggregationType";
+import MetricsViewConfig from "../../../../Types/Metrics/MetricsViewConfig";
 import MetricMonitorResponse from "../../../../Types/Monitor/MetricMonitor/MetricMonitorResponse";
 import MetricCriteriaContext, {
   MetricAnomalyBaseline,
@@ -114,12 +115,13 @@ export default class MetricMonitorCriteria {
     const seriesBreakdown: Array<MetricSeriesResult> | undefined =
       metricResponse.seriesBreakdown;
 
+    const metricViewConfig: MetricsViewConfig | undefined =
+      MonitorStep.getMetricsViewConfig(input.monitorStep);
+
     const queryConfigs: Array<MetricQueryConfigData> =
-      input.monitorStep.data?.metricMonitor?.metricViewConfig?.queryConfigs ||
-      [];
+      metricViewConfig?.queryConfigs || [];
     const formulaConfigs: Array<MetricFormulaConfigData> =
-      input.monitorStep.data?.metricMonitor?.metricViewConfig?.formulaConfigs ||
-      [];
+      metricViewConfig?.formulaConfigs || [];
 
     const nativeUnitsByMetricName: { [key: string]: string } | undefined =
       metricResponse.nativeUnitsByMetricName;

package/Server/Utils/Monitor/MonitorCriteriaDataExtractor.ts

@@ -14,6 +14,7 @@ import AggregatedResult from "../../../Types/BaseDatabase/AggregatedResult";
 import AggregateModel from "../../../Types/BaseDatabase/AggregatedModel";
 import MetricQueryConfigData from "../../../Types/Metrics/MetricQueryConfigData";
 import MetricFormulaConfigData from "../../../Types/Metrics/MetricFormulaConfigData";
+import MetricsViewConfig from "../../../Types/Metrics/MetricsViewConfig";
 import ExceptionMonitorResponse from "../../../Types/Monitor/ExceptionMonitor/ExceptionMonitorResponse";
 
 export default class MonitorCriteriaDataExtractor {
@@ -156,10 +157,12 @@ export default class MonitorCriteriaDataExtractor {
 
     let result: AggregatedResult | undefined;
 
+    const metricViewConfig: MetricsViewConfig | undefined =
+      MonitorStep.getMetricsViewConfig(input.monitorStep);
+
     if (alias) {
       const queryConfigs: Array<MetricQueryConfigData> =
-        input.monitorStep.data?.metricMonitor?.metricViewConfig?.queryConfigs ||
-        [];
+        metricViewConfig?.queryConfigs || [];
 
       let aliasIndex: number = queryConfigs.findIndex(
         (queryConfig: MetricQueryConfigData) => {
@@ -169,8 +172,7 @@ export default class MonitorCriteriaDataExtractor {
 
       if (aliasIndex < 0) {
         const formulaConfigs: Array<MetricFormulaConfigData> =
-          input.monitorStep.data?.metricMonitor?.metricViewConfig
-            ?.formulaConfigs || [];
+          metricViewConfig?.formulaConfigs || [];
 
         const formulaIndex: number = formulaConfigs.findIndex(
           (formulaConfig: MetricFormulaConfigData) => {
@@ -192,8 +194,7 @@ export default class MonitorCriteriaDataExtractor {
       result = aggregatedResults[0];
       if (!alias) {
         const defaultAlias: string | undefined =
-          input.monitorStep.data?.metricMonitor?.metricViewConfig
-            ?.queryConfigs?.[0]?.metricAliasData?.metricVariable;
+          metricViewConfig?.queryConfigs?.[0]?.metricAliasData?.metricVariable;
         alias = defaultAlias || null;
       }
     }

package/Server/Utils/Monitor/MonitorCriteriaObservationBuilder.ts

@@ -29,6 +29,7 @@ import MonitorCriteriaExpectationBuilder from "./MonitorCriteriaExpectationBuild
 import MetricMonitorResponse from "../../../Types/Monitor/MetricMonitor/MetricMonitorResponse";
 import MetricQueryConfigData from "../../../Types/Metrics/MetricQueryConfigData";
 import MetricFormulaConfigData from "../../../Types/Metrics/MetricFormulaConfigData";
+import MetricsViewConfig from "../../../Types/Metrics/MetricsViewConfig";
 import MetricUnitUtil from "../../../Utils/MetricUnitUtil";
 
 export default class MonitorCriteriaObservationBuilder {
@@ -1208,12 +1209,13 @@ export default class MonitorCriteriaObservationBuilder {
       return input.values;
     }
 
+    const metricViewConfig: MetricsViewConfig | undefined =
+      MonitorStep.getMetricsViewConfig(input.monitorStep);
+
     const queryConfigs: Array<MetricQueryConfigData> =
-      input.monitorStep.data?.metricMonitor?.metricViewConfig?.queryConfigs ||
-      [];
+      metricViewConfig?.queryConfigs || [];
     const formulaConfigs: Array<MetricFormulaConfigData> =
-      input.monitorStep.data?.metricMonitor?.metricViewConfig?.formulaConfigs ||
-      [];
+      metricViewConfig?.formulaConfigs || [];
 
     const alias: string | null = input.alias;
     const matchedQuery: MetricQueryConfigData | undefined = alias

package/Server/Utils/Telemetry/IoTSnapshotScan.ts

@@ -1,3 +1,4 @@
+import ColumnLength from "../../../Types/Database/ColumnLength";
 import OneUptimeDate from "../../../Types/Date";
 import { JSONArray, JSONObject, JSONValue } from "../../../Types/JSON";
 import logger from "../Logger";
@@ -109,6 +110,29 @@ function toNumberOrNull(value: unknown): number | null {
   return null;
 }
 
+/*
+ * A device with a future-skewed clock must not be allowed to stamp a
+ * future observedAt: it becomes lastSeenAt / metricsUpdatedAt, and the
+ * `>=` dominance guards in IoTDeviceService would then reject every
+ * legitimate (present-time) update until the wall clock catches up to
+ * the skew. Anything more than this far ahead of the ingest clock is
+ * folded back to "now" at ingest time.
+ */
+export const IOT_MAX_FUTURE_CLOCK_SKEW_MINUTES: number = 5;
+
+export function clampIoTTimestamp(date: Date, nowOverride?: Date): Date {
+  const now: Date = nowOverride || OneUptimeDate.getCurrentDate();
+  const maxAllowedMs: number =
+    now.getTime() + IOT_MAX_FUTURE_CLOCK_SKEW_MINUTES * 60 * 1000;
+  if (date.getTime() > maxAllowedMs) {
+    logger.debug(
+      `IoT timestamp ${date.toISOString()} is beyond the ${IOT_MAX_FUTURE_CLOCK_SKEW_MINUTES}m future-skew tolerance; clamping to ingest time.`,
+    );
+    return now;
+  }
+  return date;
+}
+
 /*
  * Same fall-back-to-now parse contract as the ingest service's
  * safeParseUnixNano — only the Date is needed on the snapshot path.
@@ -200,9 +224,11 @@ export function bufferIoTSnapshotMetric(data: {
     return;
   }
 
-  const observedAt: Date = parseUnixNanoToDate(
-    data.datapoint["timeUnixNano"] as string | number | undefined,
-    "iot snapshot timeUnixNano",
+  const observedAt: Date = clampIoTTimestamp(
+    parseUnixNanoToDate(
+      data.datapoint["timeUnixNano"] as string | number | undefined,
+      "iot snapshot timeUnixNano",
+    ),
   );
 
   const dpAttributes: JSONArray =
@@ -214,14 +240,26 @@ export function bufferIoTSnapshotMetric(data: {
   );
 
   // Identity lives in the `device.id` datapoint label.
-  const externalId: string | null = getStringAttribute(
-    dpAttributes,
-    "device.id",
-  );
+  let externalId: string | null = getStringAttribute(dpAttributes, "device.id");
   if (!externalId) {
     return;
   }
 
+  /*
+   * The inventory identity columns are ShortText (100 chars). Truncate
+   * over-long ids at ingest so the fold key, the inventory upsert and
+   * the latest-metric mirror all agree on the same (truncated)
+   * identity — IoTDeviceService also sanitizes before building its
+   * INSERT chunks, so one malformed device can never fail the chunk
+   * and drop the other rows with it.
+   */
+  if (externalId.length > ColumnLength.ShortText) {
+    logger.warn(
+      `IoT device.id exceeds ${ColumnLength.ShortText} chars; truncating to "${externalId.substring(0, ColumnLength.ShortText)}".`,
+    );
+    externalId = externalId.substring(0, ColumnLength.ShortText);
+  }
+
   /*
    * Kind/type/firmware: read from the iot.device.* attributes the
    * device SDK stamps; kind falls back to "Device" so inventory still

package/ServiceRoute.ts

@@ -39,3 +39,7 @@ export const DocsRoute: Route = new Route("/docs");
 export const StatusPageApiRoute: Route = new Route("/status-page-api");
 
 export const PublicDashboardRoute: Route = new Route("/public-dashboard");
+
+export const PublicDashboardApiRoute: Route = new Route(
+  "/public-dashboard-api",
+);