@oneuptime/common 11.5.8 → 11.5.10

package/Server/Utils/Monitor/MonitorMetricUtil.ts

@@ -18,6 +18,7 @@ import HttpPhaseTimings from "../../../Types/Monitor/HttpPhaseTimings";
 import MonitorMetricType from "../../../Types/Monitor/MonitorMetricType";
 import PingMonitorResponse from "../../../Types/Monitor/PingMonitor/PingMonitorResponse";
 import SnmpInterface from "../../../Types/Monitor/SnmpMonitor/SnmpInterface";
+import { SnmpOidResponse } from "../../../Types/Monitor/SnmpMonitor/SnmpMonitorResponse";
 import ProbeMonitorResponse from "../../../Types/Probe/ProbeMonitorResponse";
 import ServerMonitorResponse from "../../../Types/Monitor/ServerMonitor/ServerMonitorResponse";
 import SyntheticMonitorResponse from "../../../Types/Monitor/SyntheticMonitors/SyntheticMonitorResponse";
@@ -976,6 +977,62 @@ export default class MonitorMetricUtil {
       }
     }
 
+    /*
+     * Polled OID values (vendor-template CPU/memory/temperature and custom
+     * OIDs). Without this the values users poll every check can gate
+     * criteria but can never be charted or evaluated over time. One series
+     * per OID, keyed by the oid/oidName attributes; non-numeric values
+     * (strings, OIDs, MACs) are skipped — they carry no chartable signal.
+     */
+    const snmpOidResponses: Array<SnmpOidResponse> | undefined = (
+      data.dataToProcess as ProbeMonitorResponse
+    ).snmpResponse?.oidResponses;
+
+    if (snmpOidResponses && snmpOidResponses.length > 0) {
+      // Same unbounded-write cap rationale as the interface block above.
+      const oidResponsesToEmit: Array<SnmpOidResponse> = snmpOidResponses.slice(
+        0,
+        50,
+      );
+
+      if (oidResponsesToEmit.length < snmpOidResponses.length) {
+        logger.warn(
+          `Monitor ${data.monitorId.toString()}: emitting metrics for first ${oidResponsesToEmit.length} of ${snmpOidResponses.length} SNMP OID responses`,
+        );
+      }
+
+      for (const oidResponse of oidResponsesToEmit) {
+        const numericValue: number | undefined =
+          typeof oidResponse.value === "number" && isFinite(oidResponse.value)
+            ? oidResponse.value
+            : undefined;
+
+        if (numericValue === undefined) {
+          continue;
+        }
+
+        await this.pushMonitorMetric({
+          projectId: data.projectId,
+          monitorId: data.monitorId,
+          monitorName: data.monitorName,
+          probeName: data.probeName,
+          metricName: MonitorMetricType.SnmpOidValue,
+          value: numericValue,
+          description: "Value of a polled SNMP OID",
+          unit: "",
+          extraAttributes: {
+            probeId: (
+              data.dataToProcess as ProbeMonitorResponse
+            ).probeId.toString(),
+            oid: oidResponse.oid,
+            oidName: oidResponse.name || oidResponse.oid,
+          },
+          metricRows: metricRows,
+          metricNameServiceNameMap: metricNameServiceNameMap,
+        });
+      }
+    }
+
     if ((data.dataToProcess as ProbeMonitorResponse).httpTimings) {
       const httpTimings: HttpPhaseTimings = (
         data.dataToProcess as ProbeMonitorResponse

package/Server/Utils/Monitor/MonitorTemplateUtil.ts

@@ -15,6 +15,10 @@ import SyntheticMonitorResponse from "../../../Types/Monitor/SyntheticMonitors/S
 import SnmpMonitorResponse, {
   SnmpOidResponse,
 } from "../../../Types/Monitor/SnmpMonitor/SnmpMonitorResponse";
+import SnmpInterface from "../../../Types/Monitor/SnmpMonitor/SnmpInterface";
+import SnmpTrap, {
+  SnmpTrapVarbind,
+} from "../../../Types/Monitor/SnmpMonitor/SnmpTrap";
 import DnsMonitorResponse, {
   DnsRecordResponse,
 } from "../../../Types/Monitor/DnsMonitor/DnsMonitorResponse";
@@ -277,6 +281,96 @@ export default class MonitorTemplateUtil {
             }
           }
         }
+
+        /*
+         * Interface walk results (populated when interface monitoring is
+         * enabled on the monitor step). Counts follow the same semantics as
+         * NetworkInventoryUtil: administratively disabled interfaces are
+         * intentionally down and never count as failures, so
+         * `interfacesDown` / `downInterfaces` only cover interfaces that are
+         * admin-up but oper-down. Lets templates say
+         * "{{downInterfaces.0.name}} on {{sysName}} is down".
+         */
+        if (snmpResponse?.interfaces && snmpResponse.interfaces.length > 0) {
+          const interfaces: Array<SnmpInterface> = snmpResponse.interfaces;
+
+          const downInterfaces: Array<SnmpInterface> = interfaces.filter(
+            (snmpInterface: SnmpInterface) => {
+              return (
+                snmpInterface.isAdministrativelyUp &&
+                !snmpInterface.isOperationallyUp
+              );
+            },
+          );
+
+          storageMap["interfacesTotal"] = interfaces.length;
+          storageMap["interfacesUp"] = interfaces.filter(
+            (snmpInterface: SnmpInterface) => {
+              return (
+                snmpInterface.isAdministrativelyUp &&
+                snmpInterface.isOperationallyUp
+              );
+            },
+          ).length;
+          storageMap["interfacesDown"] = downInterfaces.length;
+          storageMap["downInterfaces"] = downInterfaces.map(
+            (snmpInterface: SnmpInterface) => {
+              return {
+                name: snmpInterface.name,
+                alias: snmpInterface.alias || "",
+                interfaceIndex: snmpInterface.interfaceIndex,
+              };
+            },
+          );
+        }
+
+        if (snmpResponse?.interfaceWalkFailure) {
+          storageMap["interfaceWalkFailure"] =
+            snmpResponse.interfaceWalkFailure;
+        }
+
+        /*
+         * Device system identity (SNMPv2 system group), when collected.
+         * Missing fields default to "" so templates render blank instead of
+         * a raw {{placeholder}} — but never clobber a value the user already
+         * exposed via a custom OID named sysName/sysDescr/etc. above.
+         */
+        if (snmpResponse?.systemInfo) {
+          const systemInfoFields: Array<[string, string | undefined]> = [
+            ["sysName", snmpResponse.systemInfo.sysName],
+            ["sysDescr", snmpResponse.systemInfo.sysDescr],
+            ["sysObjectId", snmpResponse.systemInfo.sysObjectId],
+            ["sysLocation", snmpResponse.systemInfo.sysLocation],
+          ];
+
+          for (const [fieldName, fieldValue] of systemInfoFields) {
+            if (fieldValue || storageMap[fieldName] === undefined) {
+              storageMap[fieldName] = fieldValue || "";
+            }
+          }
+        }
+
+        /*
+         * Trap payload — only present when this check was triggered by an
+         * SNMP trap received by a probe's trap receiver (rather than a
+         * scheduled poll).
+         */
+        const snmpTrapResponse: SnmpTrap | undefined = (
+          data.dataToProcess as ProbeMonitorResponse
+        ).snmpTrapResponse;
+
+        if (snmpTrapResponse) {
+          storageMap["trapOid"] = snmpTrapResponse.trapOid;
+          storageMap["trapSourceIp"] = snmpTrapResponse.sourceIpAddress;
+          storageMap["trapVarbinds"] = snmpTrapResponse.varbinds.map(
+            (varbind: SnmpTrapVarbind) => {
+              return {
+                oid: varbind.oid,
+                value: varbind.value,
+              };
+            },
+          );
+        }
       }
 
       if (data.monitorType === MonitorType.DNS) {

package/Server/Utils/Monitor/NetworkDeviceHydrationUtil.ts

@@ -4,7 +4,9 @@ import MonitorSteps from "../../../Types/Monitor/MonitorSteps";
 import QueryHelper from "../../Types/Database/QueryHelper";
 import LIMIT_MAX from "../../../Types/Database/LimitMax";
 import MonitorType from "../../../Types/Monitor/MonitorType";
-import SnmpVersion from "../../../Types/Monitor/SnmpMonitor/SnmpVersion";
+import SnmpVersion, {
+  SnmpVersionUtil,
+} from "../../../Types/Monitor/SnmpMonitor/SnmpVersion";
 import SnmpV3Auth from "../../../Types/Monitor/SnmpMonitor/SnmpV3Auth";
 import SnmpSecurityLevel from "../../../Types/Monitor/SnmpMonitor/SnmpSecurityLevel";
 import SnmpAuthProtocol from "../../../Types/Monitor/SnmpMonitor/SnmpAuthProtocol";
@@ -128,6 +130,21 @@ export default class NetworkDeviceHydrationUtil {
    * snmpV3* columns (the current storage), falling back to the deprecated
    * snmpV3Auth JSON column so devices created before the columns existed keep
    * working. Returns undefined when no v3 username is configured.
+   *
+   * The protocol columns are passed through as stored, on purpose. It is
+   * tempting to validate them here with SnmpSecurityLevelUtil /
+   * SnmpAuthProtocolUtil / SnmpPrivProtocolUtil, but this runs server-side
+   * inside the probe's monitor-list request, and that request claims its
+   * monitors — advancing nextPingAt — before hydration runs. A throw here
+   * would 500 the whole batch, so one malformed row would stall up to a
+   * hundred unrelated monitors of every type, every cycle, with nothing
+   * recorded against them.
+   *
+   * The probe validates instead, in SnmpMonitor.buildV3User, where a bad value
+   * fails exactly one monitor and shows up as its failure cause. Parsing here
+   * would defeat that by folding an unreadable value into undefined, which the
+   * probe cannot tell from "never configured" — and would therefore poll with
+   * a silently defaulted algorithm.
    */
   private static buildSnmpV3Auth(
     device: NetworkDevice,
@@ -162,16 +179,7 @@ export default class NetworkDeviceHydrationUtil {
 
   // Tolerates both enum values ("2c") and enum keys ("V2c") in stored config.
   private static parseSnmpVersion(value: string | undefined): SnmpVersion {
-    switch ((value || "").toLowerCase()) {
-      case "1":
-      case "v1":
-        return SnmpVersion.V1;
-      case "3":
-      case "v3":
-        return SnmpVersion.V3;
-      default:
-        return SnmpVersion.V2c;
-    }
+    return SnmpVersionUtil.parse(value);
   }
 
   /*

package/Server/Utils/Monitor/NetworkInventoryUtil.ts

@@ -1,4 +1,5 @@
 import Monitor from "../../../Models/DatabaseModels/Monitor";
+import NetworkDevice from "../../../Models/DatabaseModels/NetworkDevice";
 import NetworkInterface from "../../../Models/DatabaseModels/NetworkInterface";
 import NetworkDeviceService from "../../Services/NetworkDeviceService";
 import NetworkInterfaceService from "../../Services/NetworkInterfaceService";
@@ -6,6 +7,10 @@ import LIMIT_MAX from "../../../Types/Database/LimitMax";
 import MonitorStep from "../../../Types/Monitor/MonitorStep";
 import SnmpInterface from "../../../Types/Monitor/SnmpMonitor/SnmpInterface";
 import LldpNeighbor from "../../../Types/Monitor/SnmpMonitor/LldpNeighbor";
+import CdpNeighbor from "../../../Types/Monitor/SnmpMonitor/CdpNeighbor";
+import SnmpSystemInfo from "../../../Types/Monitor/SnmpMonitor/SnmpSystemInfo";
+import SnmpEntityInfo from "../../../Types/Monitor/SnmpMonitor/SnmpEntityInfo";
+import SnmpVendorTemplateUtil from "../../../Types/Monitor/SnmpMonitor/SnmpVendorTemplate";
 import ProbeMonitorResponse from "../../../Types/Probe/ProbeMonitorResponse";
 import ObjectID from "../../../Types/ObjectID";
 import OneUptimeDate from "../../../Types/Date";
@@ -41,21 +46,63 @@ export default class NetworkInventoryUtil {
     }
 
     const deviceId: ObjectID = new ObjectID(deviceIdAsString);
+
+    /*
+     * The device id is read from the monitor's step JSON, which a user can
+     * set to any UUID through the Monitor API (the dashboard dropdown is
+     * scoped, but the API is not). Confirm the device actually belongs to
+     * this monitor's project before writing anything with isRoot — without
+     * this guard a crafted step could point at another project's device and
+     * overwrite its inventory (or spawn interfaces under it).
+     */
+    const ownedDevice: NetworkDevice | null =
+      await NetworkDeviceService.findOneBy({
+        query: {
+          _id: deviceId,
+          projectId: data.monitor.projectId,
+        },
+        select: {
+          _id: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!ownedDevice) {
+      return;
+    }
+
     const walkedInterfaces: Array<SnmpInterface> =
       data.dataToProcess.snmpResponse?.interfaces || [];
-    const systemInfo:
-      | { sysDescr?: string | undefined; sysName?: string | undefined }
-      | undefined = data.dataToProcess.snmpResponse?.systemInfo;
+    const systemInfo: SnmpSystemInfo | undefined =
+      data.dataToProcess.snmpResponse?.systemInfo;
+    const entityInfo: SnmpEntityInfo | undefined =
+      data.dataToProcess.snmpResponse?.entityInfo;
     const lldpNeighbors: Array<LldpNeighbor> | undefined =
       data.dataToProcess.snmpResponse?.lldpNeighbors;
+    const cdpNeighbors: Array<CdpNeighbor> | undefined =
+      data.dataToProcess.snmpResponse?.cdpNeighbors;
 
     const now: Date = OneUptimeDate.getCurrentDate();
 
+    /*
+     * lastSeenAt is "last time the device actually answered", not "last time
+     * we tried": the device list's status pill and the topology map both
+     * derive up/down from its freshness, so bumping it on a failed poll
+     * would paint an unreachable device green. A poll where the probe could
+     * not reach the device reports isOnline === false; treat anything else
+     * (reachable, or a monitor type that reports no reachability) as seen.
+     */
+    const isDeviceReachable: boolean = data.dataToProcess.isOnline !== false;
+
     try {
       // --- Device enrichment + cached counts ---
-      const deviceUpdate: Record<string, unknown> = {
-        lastSeenAt: now,
-      };
+      const deviceUpdate: Record<string, unknown> = {};
+
+      if (isDeviceReachable) {
+        deviceUpdate["lastSeenAt"] = now;
+      }
 
       if (systemInfo?.sysDescr) {
         deviceUpdate["sysDescr"] = systemInfo.sysDescr.substring(0, 500);
@@ -63,15 +110,66 @@ export default class NetworkInventoryUtil {
       if (systemInfo?.sysName) {
         deviceUpdate["sysName"] = systemInfo.sysName.substring(0, 100);
       }
+      if (systemInfo?.sysObjectId) {
+        deviceUpdate["sysObjectId"] = systemInfo.sysObjectId.substring(0, 100);
+      }
+      if (systemInfo?.sysLocation) {
+        deviceUpdate["sysLocation"] = systemInfo.sysLocation.substring(0, 100);
+      }
+      if (systemInfo?.sysContact) {
+        deviceUpdate["sysContact"] = systemInfo.sysContact.substring(0, 100);
+      }
+      if (systemInfo?.sysUpTimeSeconds !== undefined) {
+        deviceUpdate["lastRebootedAt"] = new Date(
+          now.getTime() - systemInfo.sysUpTimeSeconds * 1000,
+        );
+      }
+
+      /*
+       * Vendor: ENTITY-MIB manufacturer when the device implements it,
+       * otherwise fingerprinted from the sysObjectID enterprise arc.
+       */
+      const vendor: string | undefined =
+        entityInfo?.manufacturer ||
+        SnmpVendorTemplateUtil.getVendorNameBySysObjectId(
+          systemInfo?.sysObjectId,
+        );
+      if (vendor) {
+        deviceUpdate["vendor"] = vendor.substring(0, 100);
+      }
+      if (entityInfo?.model) {
+        deviceUpdate["deviceModel"] = entityInfo.model.substring(0, 100);
+      }
+      if (entityInfo?.serialNumber) {
+        deviceUpdate["serialNumber"] = entityInfo.serialNumber.substring(
+          0,
+          100,
+        );
+      }
+      if (entityInfo?.firmwareVersion) {
+        deviceUpdate["firmwareVersion"] = entityInfo.firmwareVersion.substring(
+          0,
+          100,
+        );
+      }
+      if (entityInfo?.softwareVersion) {
+        deviceUpdate["softwareVersion"] = entityInfo.softwareVersion.substring(
+          0,
+          100,
+        );
+      }
 
       /*
        * Store the LLDP snapshot (capped) whenever the walk ran, even if it
        * found nothing — clearing stale neighbors is as important as adding
-       * new ones for keeping the topology accurate.
+       * new ones for keeping the topology accurate. Same for CDP.
        */
       if (lldpNeighbors !== undefined) {
         deviceUpdate["lldpNeighbors"] = lldpNeighbors.slice(0, 256);
       }
+      if (cdpNeighbors !== undefined) {
+        deviceUpdate["cdpNeighbors"] = cdpNeighbors.slice(0, 256);
+      }
 
       if (walkedInterfaces.length > 0) {
         deviceUpdate["interfacesTotal"] = walkedInterfaces.length;
@@ -87,13 +185,16 @@ export default class NetworkInventoryUtil {
         ).length;
       }
 
-      await NetworkDeviceService.updateOneById({
-        id: deviceId,
-        data: deviceUpdate as any,
-        props: {
-          isRoot: true,
-        },
-      });
+      // An unreachable poll with no walk data leaves nothing worth writing.
+      if (Object.keys(deviceUpdate).length > 0) {
+        await NetworkDeviceService.updateOneById({
+          id: deviceId,
+          data: deviceUpdate as any,
+          props: {
+            isRoot: true,
+          },
+        });
+      }
 
       if (walkedInterfaces.length === 0) {
         return;
@@ -138,6 +239,10 @@ export default class NetworkInventoryUtil {
         const interfaceData: Record<string, unknown> = {
           name: (walked.name || "").substring(0, 100),
           alias: walked.alias ? walked.alias.substring(0, 100) : null,
+          macAddress: walked.macAddress
+            ? walked.macAddress.substring(0, 100)
+            : null,
+          interfaceType: walked.interfaceType ?? null,
           isOperationallyUp: walked.isOperationallyUp,
           isAdministrativelyUp: walked.isAdministrativelyUp,
           speedInMbps:
@@ -174,6 +279,12 @@ export default class NetworkInventoryUtil {
           if (walked.alias) {
             newInterface.alias = walked.alias.substring(0, 100);
           }
+          if (walked.macAddress) {
+            newInterface.macAddress = walked.macAddress.substring(0, 100);
+          }
+          if (walked.interfaceType !== undefined) {
+            newInterface.interfaceType = walked.interfaceType;
+          }
           newInterface.isMonitored = true;
           newInterface.isOperationallyUp = walked.isOperationallyUp;
           newInterface.isAdministrativelyUp = walked.isAdministrativelyUp;

package/Server/Utils/ProductAnalytics.ts

@@ -0,0 +1,133 @@
+import { AnalyticsHost, AnalyticsKey } from "../EnvironmentConfig";
+import UserService from "../Services/UserService";
+import HTTPErrorResponse from "../../Types/API/HTTPErrorResponse";
+import HTTPResponse from "../../Types/API/HTTPResponse";
+import URL from "../../Types/API/URL";
+import { JSONObject } from "../../Types/JSON";
+import ObjectID from "../../Types/ObjectID";
+import User from "../../Models/DatabaseModels/User";
+import API from "../../Utils/API";
+import logger from "./Logger";
+
+/*
+ * Server-side product analytics (PostHog).
+ *
+ * Client-side events are lost to ad blockers — common with OneUptime's
+ * developer audience — so revenue and activation events are also captured
+ * here, where they cannot be blocked.
+ *
+ * Events are identified by the user's email (the same distinct id the
+ * frontends use via posthog.identify) so server and client events join into
+ * one person profile.
+ *
+ * No-ops when ANALYTICS_KEY / ANALYTICS_HOST are not configured (the default
+ * for self-hosted installs). Never throws — analytics must not break the
+ * product.
+ */
+export default class ProductAnalytics {
+  public static isConfigured(): boolean {
+    return Boolean(AnalyticsKey && AnalyticsHost);
+  }
+
+  public static capture(data: {
+    event: string;
+    distinctId: string;
+    properties?: JSONObject | undefined;
+  }): void {
+    try {
+      if (!this.isConfigured()) {
+        return;
+      }
+
+      if (!data.distinctId) {
+        return;
+      }
+
+      API.post<JSONObject>({
+        url: URL.fromString(AnalyticsHost.toString()).addRoute("/capture/"),
+        data: {
+          api_key: AnalyticsKey,
+          event: data.event,
+          distinct_id: data.distinctId,
+          properties: {
+            source: "oneuptime-server",
+            ...(data.properties || {}),
+          },
+        },
+      })
+        .then((result: HTTPResponse<JSONObject> | HTTPErrorResponse) => {
+          /*
+           * API.post resolves (does not reject) on HTTP error statuses, so a
+           * misconfigured ANALYTICS_KEY (401) or malformed body (400) must be
+           * surfaced here or events vanish with no log signal.
+           */
+          if (result instanceof HTTPErrorResponse) {
+            logger.error(
+              `ProductAnalytics capture failed for event ${data.event}: HTTP ${result.statusCode} ${result.message}`,
+            );
+          }
+        })
+        .catch((err: Error) => {
+          logger.error("ProductAnalytics capture failed:");
+          logger.error(err);
+        });
+    } catch (err) {
+      /*
+       * e.g. URL.fromString throws on a malformed ANALYTICS_HOST. Analytics
+       * runs inside request-path hooks (signup, project create, plan change)
+       * and must never fail those requests.
+       */
+      logger.error("ProductAnalytics capture failed:");
+      logger.error(err as Error);
+    }
+  }
+
+  /*
+   * Capture an event attributed to a user by id, resolving the user's email
+   * to use as the distinct id. Skips silently when the user cannot be
+   * resolved (e.g. records created by probes, workflows or API keys).
+   */
+  public static captureForUser(data: {
+    userId: ObjectID | undefined | null;
+    event: string;
+    properties?: JSONObject | undefined;
+  }): void {
+    try {
+      if (!this.isConfigured()) {
+        return;
+      }
+
+      if (!data.userId) {
+        return;
+      }
+
+      UserService.findOneById({
+        id: data.userId,
+        select: {
+          email: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      })
+        .then((user: User | null) => {
+          if (!user || !user.email) {
+            return;
+          }
+
+          this.capture({
+            event: data.event,
+            distinctId: user.email.toString(),
+            properties: data.properties,
+          });
+        })
+        .catch((err: Error) => {
+          logger.error("ProductAnalytics captureForUser failed:");
+          logger.error(err);
+        });
+    } catch (err) {
+      logger.error("ProductAnalytics captureForUser failed:");
+      logger.error(err as Error);
+    }
+  }
+}

package/Server/Utils/Telemetry/Telemetry.ts

@@ -26,6 +26,8 @@ export default class TelemetryUtil {
           name: true,
           description: true,
           unit: true,
+          isMonotonic: true,
+          aggregationTemporality: true,
         },
         props: {
           isRoot: true,
@@ -66,6 +68,30 @@ export default class TelemetryUtil {
           metricType.unit = metricTypeInMap.unit || "";
         }
 
+        /*
+         * Counter semantics (isMonotonic / aggregationTemporality) are only
+         * known on OTel metric ingest paths — other callers (monitor
+         * metrics, heartbeat metrics) never set them, so an undefined
+         * incoming value means "unknown", not "clear the stored value".
+         */
+        if (
+          metricTypeInMap.isMonotonic !== undefined &&
+          metricType.isMonotonic !== metricTypeInMap.isMonotonic
+        ) {
+          isSame = false;
+          metricType.isMonotonic = metricTypeInMap.isMonotonic;
+        }
+
+        if (
+          metricTypeInMap.aggregationTemporality !== undefined &&
+          metricType.aggregationTemporality !==
+            metricTypeInMap.aggregationTemporality
+        ) {
+          isSame = false;
+          metricType.aggregationTemporality =
+            metricTypeInMap.aggregationTemporality;
+        }
+
         // check if services are same
 
         for (const serviceId of servicesInMap) {
@@ -92,6 +118,12 @@ export default class TelemetryUtil {
               services: metricType.services || [],
               description: metricTypeInMap.description || "",
               unit: metricTypeInMap.unit || "",
+              ...(metricType.isMonotonic !== undefined
+                ? { isMonotonic: metricType.isMonotonic }
+                : {}),
+              ...(metricType.aggregationTemporality !== undefined
+                ? { aggregationTemporality: metricType.aggregationTemporality }
+                : {}),
             },
             props: {
               isRoot: true,
@@ -104,6 +136,13 @@ export default class TelemetryUtil {
         metricType.name = metricName;
         metricType.description = metricTypeInMap.description || "";
         metricType.unit = metricTypeInMap.unit || "";
+        if (metricTypeInMap.isMonotonic !== undefined) {
+          metricType.isMonotonic = metricTypeInMap.isMonotonic;
+        }
+        if (metricTypeInMap.aggregationTemporality !== undefined) {
+          metricType.aggregationTemporality =
+            metricTypeInMap.aggregationTemporality;
+        }
         metricType.projectId = data.projectId;
         metricType.services = [];
 

package/Server/Utils/Telemetry/TelemetryEntity.ts

@@ -888,3 +888,24 @@ export default class TelemetryEntity {
     return out;
   }
 }
+
+/**
+ * `container.id` is the container identity (mirrors the container
+ * resolver above — id-only). Read-side helper in the mold of
+ * `EntityKey.keyForHost` & co.; it lives here rather than in the
+ * isomorphic EntityKey module because its only consumer today is the
+ * server-side container metric-rollup read path
+ * (`MetricService.tryBuildEntityAggregateMVStatement` against
+ * `MetricItemAggMV1mByContainer`), so there is no reason to widen the
+ * browser bundle. Pass the raw `container.id` attribute value.
+ */
+export function keyForContainer(
+  projectId: string,
+  containerId: string,
+): string {
+  return computeEntityKeyShared({
+    projectId,
+    entityType: EntityType.Container,
+    identifyingAttributes: { "container.id": containerId },
+  });
+}