@oneuptime/common 11.3.20 → 11.3.21

package/Tests/Server/Utils/Telemetry/IoTSnapshotScan.test.ts

@@ -0,0 +1,202 @@
+import {
+  IoTDeviceBufferEntry,
+  IoTFleetSnapshotBufferEntry,
+  IOT_MAX_FUTURE_CLOCK_SKEW_MINUTES,
+  bufferIoTSnapshotMetric,
+  clampIoTTimestamp,
+} from "../../../../Server/Utils/Telemetry/IoTSnapshotScan";
+import { JSONObject } from "../../../../Types/JSON";
+
+/*
+ * Malformed-device hardening for the IoT snapshot scan:
+ *
+ *   - a `device.id` longer than the ShortText column limit (100) is
+ *     truncated at ingest, so one bad device can never fail the
+ *     500-row inventory INSERT chunk downstream — and two ids sharing
+ *     the truncated prefix fold into ONE entry (a duplicate conflict
+ *     target inside a single INSERT would abort the statement),
+ *   - a future-skewed device clock is clamped to ingest time, so the
+ *     `>=` lastSeenAt dominance guard can't get wedged by one bogus
+ *     future timestamp and then reject every legitimate update.
+ */
+
+const FLEET: string = "0a1b2c3d-0000-0000-0000-000000000001";
+const SHORT_TEXT_LIMIT: number = 100;
+
+type LabelMap = Record<string, string>;
+
+function toNano(ms: number): string {
+  return `${ms}000000`;
+}
+
+function datapoint(data: {
+  value: number;
+  atMs?: number;
+  labels?: LabelMap;
+  asDouble?: boolean;
+}): JSONObject {
+  const attributes: Array<JSONObject> = Object.entries(data.labels || {}).map(
+    ([key, value]: [string, string]) => {
+      return { key, value: { stringValue: value } };
+    },
+  );
+  return {
+    ...(data.asDouble ? { asDouble: data.value } : { asInt: data.value }),
+    timeUnixNano: toNano(data.atMs ?? Date.now()),
+    attributes,
+  };
+}
+
+interface IoTBuffers {
+  resourceBuffer: Map<string, Map<string, IoTDeviceBufferEntry>>;
+  fleetBuffer: Map<string, IoTFleetSnapshotBufferEntry>;
+}
+
+function iotBuffers(): IoTBuffers {
+  return { resourceBuffer: new Map(), fleetBuffer: new Map() };
+}
+
+function feed(buffers: IoTBuffers, metricName: string, dp: JSONObject): void {
+  bufferIoTSnapshotMetric({
+    fleetIdStr: FLEET,
+    metricName,
+    datapoint: dp,
+    resourceBuffer: buffers.resourceBuffer,
+    fleetBuffer: buffers.fleetBuffer,
+  });
+}
+
+function entries(buffers: IoTBuffers): Array<IoTDeviceBufferEntry> {
+  return Array.from(buffers.resourceBuffer.get(FLEET)?.values() || []);
+}
+
+describe("clampIoTTimestamp", () => {
+  const now: Date = new Date("2026-07-02T12:00:00.000Z");
+
+  test("keeps a past timestamp untouched", () => {
+    const past: Date = new Date("2026-07-02T11:00:00.000Z");
+    expect(clampIoTTimestamp(past, now)).toEqual(past);
+  });
+
+  test("keeps a future timestamp within the skew tolerance", () => {
+    const slightlyAhead: Date = new Date(
+      now.getTime() + (IOT_MAX_FUTURE_CLOCK_SKEW_MINUTES - 1) * 60 * 1000,
+    );
+    expect(clampIoTTimestamp(slightlyAhead, now)).toEqual(slightlyAhead);
+  });
+
+  test("clamps a timestamp beyond the skew tolerance back to now", () => {
+    const farAhead: Date = new Date(now.getTime() + 60 * 60 * 1000);
+    expect(clampIoTTimestamp(farAhead, now)).toEqual(now);
+  });
+});
+
+describe("bufferIoTSnapshotMetric — device.id length hardening", () => {
+  test("truncates a device.id longer than the 100-char column limit", () => {
+    const longId: string = "x".repeat(150);
+    const buffers: IoTBuffers = iotBuffers();
+
+    feed(buffers, "iot_device_up", {
+      ...datapoint({ value: 1, labels: { "device.id": longId } }),
+    });
+
+    const buffered: Array<IoTDeviceBufferEntry> = entries(buffers);
+    expect(buffered).toHaveLength(1);
+    expect(buffered[0]!.externalId).toBe("x".repeat(SHORT_TEXT_LIMIT));
+    expect(buffered[0]!.externalId.length).toBe(SHORT_TEXT_LIMIT);
+  });
+
+  test("keeps a device.id exactly at the column limit untouched", () => {
+    const exactId: string = "y".repeat(SHORT_TEXT_LIMIT);
+    const buffers: IoTBuffers = iotBuffers();
+
+    feed(buffers, "iot_device_up", {
+      ...datapoint({ value: 1, labels: { "device.id": exactId } }),
+    });
+
+    expect(entries(buffers)[0]!.externalId).toBe(exactId);
+  });
+
+  test("two over-long ids sharing the truncated prefix fold into one entry", () => {
+    const shared: string = "z".repeat(SHORT_TEXT_LIMIT);
+    const buffers: IoTBuffers = iotBuffers();
+
+    feed(buffers, "iot_device_up", {
+      ...datapoint({ value: 1, labels: { "device.id": `${shared}-alpha` } }),
+    });
+    feed(buffers, "iot_device_up", {
+      ...datapoint({ value: 0, labels: { "device.id": `${shared}-bravo` } }),
+    });
+
+    // One folded identity — never two rows hitting one conflict target.
+    const buffered: Array<IoTDeviceBufferEntry> = entries(buffers);
+    expect(buffered).toHaveLength(1);
+    expect(buffered[0]!.externalId).toBe(shared);
+  });
+});
+
+describe("bufferIoTSnapshotMetric — future clock-skew hardening", () => {
+  test("clamps an observedAt beyond the skew tolerance to ingest time", () => {
+    const buffers: IoTBuffers = iotBuffers();
+    const before: number = Date.now();
+
+    feed(buffers, "iot_battery_percent", {
+      ...datapoint({
+        value: 55,
+        asDouble: true,
+        atMs: Date.now() + 60 * 60 * 1000, // device clock 1h ahead
+        labels: { "device.id": "sensor-1" },
+      }),
+    });
+
+    const after: number = Date.now();
+    const observedAt: Date = entries(buffers)[0]!.observedAt;
+    expect(observedAt.getTime()).toBeGreaterThanOrEqual(before);
+    expect(observedAt.getTime()).toBeLessThanOrEqual(after);
+  });
+
+  test("keeps an observedAt within the skew tolerance untouched", () => {
+    const buffers: IoTBuffers = iotBuffers();
+    const slightlyAheadMs: number =
+      Date.now() + (IOT_MAX_FUTURE_CLOCK_SKEW_MINUTES - 1) * 60 * 1000;
+
+    feed(buffers, "iot_battery_percent", {
+      ...datapoint({
+        value: 55,
+        asDouble: true,
+        atMs: slightlyAheadMs,
+        labels: { "device.id": "sensor-1" },
+      }),
+    });
+
+    expect(entries(buffers)[0]!.observedAt.getTime()).toBe(
+      Math.trunc(slightlyAheadMs),
+    );
+  });
+
+  test("a clamped future point no longer wedges newest-wins folding", () => {
+    const buffers: IoTBuffers = iotBuffers();
+
+    // Skewed device stamps 1h ahead — clamped to ~now at ingest.
+    feed(buffers, "iot_battery_percent", {
+      ...datapoint({
+        value: 50,
+        asDouble: true,
+        atMs: Date.now() + 60 * 60 * 1000,
+        labels: { "device.id": "sensor-1" },
+      }),
+    });
+
+    // A legitimate later reading must still win the fold.
+    feed(buffers, "iot_battery_percent", {
+      ...datapoint({
+        value: 80,
+        asDouble: true,
+        atMs: Date.now() + 1000,
+        labels: { "device.id": "sensor-1" },
+      }),
+    });
+
+    expect(entries(buffers)[0]!.latestBatteryPercent).toBe(80);
+  });
+});

package/Tests/Utils/EnterpriseLicenseUsage.test.ts

@@ -0,0 +1,165 @@
+import EnterpriseLicenseUsageUtil from "../../Utils/EnterpriseLicense/EnterpriseLicenseUsage";
+import OneUptimeDate from "../../Types/Date";
+import { describe, expect, it } from "@jest/globals";
+
+type HashFunction = (seed: string) => string;
+
+// Deterministic fake SHA-256-shaped hex string for tests.
+const fakeHash: HashFunction = (seed: string): string => {
+  return seed
+    .repeat(64)
+    .replace(/[^a-f0-9]/g, "a")
+    .substring(0, 64);
+};
+
+describe("EnterpriseLicenseUsageUtil.sanitizeUserEmailHashes", () => {
+  it("returns empty array for non-array input", () => {
+    expect(EnterpriseLicenseUsageUtil.sanitizeUserEmailHashes(null)).toEqual(
+      [],
+    );
+    expect(
+      EnterpriseLicenseUsageUtil.sanitizeUserEmailHashes("not-an-array"),
+    ).toEqual([]);
+    expect(EnterpriseLicenseUsageUtil.sanitizeUserEmailHashes({})).toEqual([]);
+  });
+
+  it("keeps only valid sha256 hex strings and normalizes case", () => {
+    const valid: string = fakeHash("1");
+
+    const result: Array<string> =
+      EnterpriseLicenseUsageUtil.sanitizeUserEmailHashes([
+        valid.toUpperCase(),
+        ` ${valid} `,
+        "short",
+        12345,
+        "z".repeat(64), // not hex
+        null,
+      ]);
+
+    expect(result).toEqual([valid]);
+  });
+
+  it("removes duplicates", () => {
+    const a: string = fakeHash("a");
+    const b: string = fakeHash("b");
+
+    const result: Array<string> =
+      EnterpriseLicenseUsageUtil.sanitizeUserEmailHashes([a, b, a, b, a]);
+
+    expect(result.sort()).toEqual([a, b].sort());
+  });
+});
+
+describe("EnterpriseLicenseUsageUtil.getUniqueUserCount", () => {
+  const now: Date = OneUptimeDate.getCurrentDate();
+  const fresh: Date = OneUptimeDate.addRemoveDays(now, -1);
+  const stale: Date = OneUptimeDate.addRemoveDays(now, -60);
+
+  it("counts the same user on multiple instances once", () => {
+    const sharedUser: string = fakeHash("shared");
+    const stagingOnlyUser: string = fakeHash("staging");
+    const prodOnlyUser: string = fakeHash("prod");
+
+    const count: number = EnterpriseLicenseUsageUtil.getUniqueUserCount(
+      [
+        {
+          userCount: 2,
+          userEmailHashes: [sharedUser, stagingOnlyUser],
+          lastReportedAt: fresh,
+        },
+        {
+          userCount: 2,
+          userEmailHashes: [sharedUser, prodOnlyUser],
+          lastReportedAt: fresh,
+        },
+      ],
+      now,
+    );
+
+    expect(count).toBe(3);
+  });
+
+  it("adds plain user counts for instances without hashes", () => {
+    const count: number = EnterpriseLicenseUsageUtil.getUniqueUserCount(
+      [
+        {
+          userCount: 2,
+          userEmailHashes: [fakeHash("a"), fakeHash("b")],
+          lastReportedAt: fresh,
+        },
+        {
+          // Older installation that reports a count but no hashes.
+          userCount: 7,
+          userEmailHashes: undefined,
+          lastReportedAt: fresh,
+        },
+      ],
+      now,
+    );
+
+    expect(count).toBe(9);
+  });
+
+  it("counts overflow users when the hash list was capped", () => {
+    /*
+     * An instance with more users than the hash cap: userCount is larger
+     * than the number of hashes stored. The overflow must still count.
+     */
+    const count: number = EnterpriseLicenseUsageUtil.getUniqueUserCount(
+      [
+        {
+          userCount: 250_000,
+          userEmailHashes: [fakeHash("a"), fakeHash("b")], // capped list
+          lastReportedAt: fresh,
+        },
+      ],
+      now,
+    );
+
+    expect(count).toBe(250_000);
+  });
+
+  it("ignores instances that stopped reporting", () => {
+    const count: number = EnterpriseLicenseUsageUtil.getUniqueUserCount(
+      [
+        {
+          userCount: 4,
+          userEmailHashes: [
+            fakeHash("a"),
+            fakeHash("b"),
+            fakeHash("c"),
+            fakeHash("d"),
+          ],
+          lastReportedAt: fresh,
+        },
+        {
+          userCount: 100,
+          userEmailHashes: [fakeHash("e")],
+          lastReportedAt: stale,
+        },
+      ],
+      now,
+    );
+
+    expect(count).toBe(4);
+  });
+
+  it("ignores instances that never reported", () => {
+    const count: number = EnterpriseLicenseUsageUtil.getUniqueUserCount(
+      [
+        {
+          userCount: undefined,
+          userEmailHashes: undefined,
+          lastReportedAt: undefined,
+        },
+      ],
+      now,
+    );
+
+    expect(count).toBe(0);
+  });
+
+  it("returns 0 for no instances", () => {
+    expect(EnterpriseLicenseUsageUtil.getUniqueUserCount([], now)).toBe(0);
+  });
+});

package/Types/EnterpriseLicense/EnterpriseLicenseInstanceSummary.ts

@@ -0,0 +1,18 @@
+/*
+ * Summary of a self-hosted OneUptime instance that uses an enterprise
+ * license. Returned by the license server (oneuptime.com) on validate and
+ * report-user-count calls, stored in GlobalConfig on the customer's
+ * instances, and shown in the license modal.
+ *
+ * Kept as a `type` of plain primitives (not an interface) so it stays
+ * structurally compatible with JSONObject and safe to store in JSON columns.
+ */
+type EnterpriseLicenseInstanceSummary = {
+  instanceId: string;
+  host: string | null;
+  userCount: number | null;
+  // ISO date string of the most recent usage report from this instance.
+  lastReportedAt: string | null;
+};
+
+export default EnterpriseLicenseInstanceSummary;

package/Types/Monitor/MonitorStep.ts

@@ -68,6 +68,7 @@ import MonitorStepCephMonitor, {
 import MonitorStepIoTMonitor, {
   MonitorStepIoTMonitorUtil,
 } from "./MonitorStepIoTMonitor";
+import MetricsViewConfig from "../Metrics/MetricsViewConfig";
 import Zod, { ZodSchema } from "../../Utils/Schema/Zod";
 
 /*
@@ -305,6 +306,37 @@ export default class MonitorStep extends DatabaseProperty {
     return monitorStep;
   }
 
+  /**
+   * Telemetry monitor steps store their metric query configs under their
+   * own step shape (metricMonitor, iotMonitor, kubernetesMonitor, ...),
+   * yet all of them produce a MetricMonitorResponse whose result slots
+   * are ordered by these configs. Criteria evaluation must resolve
+   * metric aliases through whichever shape the step carries — reading
+   * only `metricMonitor` silently falls back to result slot 0 for every
+   * other telemetry monitor type.
+   */
+  public static getMetricsViewConfig(
+    monitorStep: MonitorStep | undefined,
+  ): MetricsViewConfig | undefined {
+    const data: MonitorStepType | undefined = monitorStep?.data;
+
+    if (!data) {
+      return undefined;
+    }
+
+    return (
+      data.metricMonitor?.metricViewConfig ||
+      data.iotMonitor?.metricViewConfig ||
+      data.kubernetesMonitor?.metricViewConfig ||
+      data.dockerMonitor?.metricViewConfig ||
+      data.dockerSwarmMonitor?.metricViewConfig ||
+      data.hostMonitor?.metricViewConfig ||
+      data.podmanMonitor?.metricViewConfig ||
+      data.proxmoxMonitor?.metricViewConfig ||
+      data.cephMonitor?.metricViewConfig
+    );
+  }
+
   public get id(): ObjectID {
     return new ObjectID(this.data?.id as string);
   }

package/UI/Components/EditionLabel/EditionLabel.tsx

@@ -27,6 +27,7 @@ import {
   IS_ENTERPRISE_EDITION,
 } from "../../Config";
 import Alert, { AlertType } from "../Alerts/Alert";
+import EnterpriseLicenseInstanceSummary from "../../../Types/EnterpriseLicense/EnterpriseLicenseInstanceSummary";
 
 export interface ComponentProps {
   className?: string | undefined;
@@ -34,6 +35,69 @@ export interface ComponentProps {
 
 const ENTERPRISE_URL: string = "https://oneuptime.com/enterprise/demo";
 
+type ParseLicenseInstancesFunction = (
+  value: unknown,
+) => Array<EnterpriseLicenseInstanceSummary>;
+
+const parseLicenseInstances: ParseLicenseInstancesFunction = (
+  value: unknown,
+): Array<EnterpriseLicenseInstanceSummary> => {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  const instances: Array<EnterpriseLicenseInstanceSummary> = [];
+
+  for (const item of value) {
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+
+    const instance: JSONObject = item as JSONObject;
+
+    instances.push({
+      instanceId:
+        typeof instance["instanceId"] === "string"
+          ? instance["instanceId"]
+          : "",
+      host:
+        typeof instance["host"] === "string" && instance["host"]
+          ? instance["host"]
+          : null,
+      userCount:
+        typeof instance["userCount"] === "number"
+          ? instance["userCount"]
+          : null,
+      lastReportedAt:
+        typeof instance["lastReportedAt"] === "string"
+          ? instance["lastReportedAt"]
+          : null,
+    });
+  }
+
+  return instances;
+};
+
+type FormatInstanceReportedAtFunction = (
+  lastReportedAt: string | null,
+) => string;
+
+const formatInstanceReportedAt: FormatInstanceReportedAtFunction = (
+  lastReportedAt: string | null,
+): string => {
+  if (!lastReportedAt) {
+    return "No usage reported yet.";
+  }
+
+  const reportedAt: Date = OneUptimeDate.fromString(lastReportedAt);
+
+  if (Number.isNaN(reportedAt.getTime())) {
+    return "No usage reported yet.";
+  }
+
+  return `Last reported ${reportedAt.toLocaleString()}.`;
+};
+
 const EditionLabel: FunctionComponent<ComponentProps> = (
   props: ComponentProps,
 ): ReactElement => {
@@ -46,6 +110,18 @@ const EditionLabel: FunctionComponent<ComponentProps> = (
   const [successMessage, setSuccessMessage] = useState<string>("");
   const [isValidating, setIsValidating] = useState<boolean>(false);
   const [isChangingLicense, setIsChangingLicense] = useState<boolean>(false);
+  const [licenseInstances, setLicenseInstances] = useState<
+    Array<EnterpriseLicenseInstanceSummary>
+  >([]);
+  const [thisInstanceId, setThisInstanceId] = useState<string>("");
+  /*
+   * Validity as computed by the server. The server redacts the license
+   * token for signed-out visitors (e.g. on the login page), so the client
+   * cannot always derive validity from the token itself.
+   */
+  const [serverLicenseValid, setServerLicenseValid] = useState<boolean | null>(
+    null,
+  );
   const licenseInputEditedRef: React.MutableRefObject<boolean> =
     useRef<boolean>(false);
 
@@ -117,12 +193,25 @@ const EditionLabel: FunctionComponent<ComponentProps> = (
         }
 
         setGlobalConfig(configModel);
+        setLicenseInstances(parseLicenseInstances(payload["instances"]));
+        setThisInstanceId(
+          typeof payload["instanceId"] === "string"
+            ? payload["instanceId"]
+            : "",
+        );
+        setServerLicenseValid(
+          typeof payload["licenseValid"] === "boolean"
+            ? payload["licenseValid"]
+            : null,
+        );
 
         if (!licenseInputEditedRef.current) {
           setLicenseKeyInput(configModel.enterpriseLicenseKey || "");
         }
       } catch (err) {
         setGlobalConfig(null);
+        setLicenseInstances([]);
+        setServerLicenseValid(null);
         setConfigError(API.getFriendlyMessage(err));
       } finally {
         setIsConfigLoading(false);
@@ -138,6 +227,11 @@ const EditionLabel: FunctionComponent<ComponentProps> = (
       return false;
     }
 
+    // Prefer the server's verdict (works even when the token is redacted).
+    if (serverLicenseValid !== null) {
+      return serverLicenseValid;
+    }
+
     if (
       !globalConfig?.enterpriseLicenseToken ||
       !globalConfig.enterpriseLicenseExpiresAt
@@ -153,6 +247,7 @@ const EditionLabel: FunctionComponent<ComponentProps> = (
   }, [
     globalConfig?.enterpriseLicenseExpiresAt,
     globalConfig?.enterpriseLicenseToken,
+    serverLicenseValid,
   ]);
 
   const licenseExpiresAtText: string | null = useMemo(() => {
@@ -626,6 +721,15 @@ const EditionLabel: FunctionComponent<ComponentProps> = (
                           </p>
                         )}
 
+                        {licenseInstances.length > 1 && (
+                          <p className="mt-3 text-xs text-gray-500">
+                            Users are counted uniquely across all{" "}
+                            {licenseInstances.length} instances that share this
+                            license — the same user on multiple instances uses
+                            one seat.
+                          </p>
+                        )}
+
                         <p className="mt-3 text-xs text-gray-500">
                           {userCountUpdatedAtText
                             ? `Last reported to OneUptime on ${userCountUpdatedAtText}.`
@@ -636,6 +740,74 @@ const EditionLabel: FunctionComponent<ComponentProps> = (
                   </div>
                 )}
 
+                {!configError &&
+                  !isConfigLoading &&
+                  licenseValid &&
+                  licenseInstances.length > 0 && (
+                    <div className="rounded-lg border border-gray-200 bg-white p-4 shadow-sm">
+                      <div className="flex items-center justify-between">
+                        <h3 className="text-sm font-semibold text-gray-900">
+                          Instances using this license
+                        </h3>
+                        <span className="text-xs text-gray-500">
+                          {licenseInstances.length}{" "}
+                          {licenseInstances.length === 1
+                            ? "instance"
+                            : "instances"}
+                        </span>
+                      </div>
+                      <p className="mt-1 text-xs text-gray-500">
+                        Use the same license key on every instance you deploy
+                        (staging, production, and so on). Each instance reports
+                        its usage daily.
+                      </p>
+                      <ul className="mt-3 divide-y divide-gray-100">
+                        {licenseInstances.map(
+                          (
+                            instance: EnterpriseLicenseInstanceSummary,
+                            index: number,
+                          ) => {
+                            const isThisInstance: boolean =
+                              Boolean(thisInstanceId) &&
+                              instance.instanceId === thisInstanceId;
+
+                            return (
+                              <li
+                                key={instance.instanceId || index}
+                                className="flex items-center justify-between gap-3 py-2"
+                              >
+                                <div className="min-w-0">
+                                  <p className="truncate text-sm font-medium text-gray-900">
+                                    {instance.host || "Unknown host"}
+                                    {isThisInstance && (
+                                      <span className="ml-2 inline-flex items-center rounded-full bg-indigo-100 px-2 py-0.5 text-xs font-medium text-indigo-700">
+                                        This instance
+                                      </span>
+                                    )}
+                                  </p>
+                                  <p className="text-xs text-gray-500">
+                                    {formatInstanceReportedAt(
+                                      instance.lastReportedAt,
+                                    )}
+                                  </p>
+                                </div>
+                                <div className="shrink-0 text-right text-sm text-gray-700">
+                                  {typeof instance.userCount === "number"
+                                    ? `${instance.userCount.toLocaleString()} ${
+                                        instance.userCount === 1
+                                          ? "user"
+                                          : "users"
+                                      }`
+                                    : "—"}
+                                </div>
+                              </li>
+                            );
+                          },
+                        )}
+                      </ul>
+                    </div>
+                  )}
+
                 {!configError &&
                   !isConfigLoading &&
                   licenseValid &&