@oneuptime/common 11.5.9 → 11.5.11

package/Utils/Monitor/NetworkTopologyUtil.ts

@@ -1,9 +1,12 @@
 import NetworkTopology, {
   NetworkTopologyEdge,
+  NetworkTopologyEdgeEndpoint,
+  NetworkTopologyLinkProtocol,
   NetworkTopologyNode,
   NetworkTopologyNodeStatus,
 } from "../../Types/Monitor/SnmpMonitor/NetworkTopology";
 import LldpNeighbor from "../../Types/Monitor/SnmpMonitor/LldpNeighbor";
+import CdpNeighbor from "../../Types/Monitor/SnmpMonitor/CdpNeighbor";
 
 export interface TopologyDeviceInput {
   id: string;
@@ -13,7 +16,41 @@ export interface TopologyDeviceInput {
   lastSeenAt?: Date | undefined;
   interfacesUp?: number | undefined;
   interfacesDown?: number | undefined;
+  vendor?: string | undefined;
+  deviceModel?: string | undefined;
   lldpNeighbors?: Array<LldpNeighbor> | undefined;
+  cdpNeighbors?: Array<CdpNeighbor> | undefined;
+}
+
+/*
+ * One NetworkInterface row, reduced to what edge enrichment needs. The
+ * caller queries interfaces for all devices in the graph in one go and
+ * passes them here; matching happens in memory.
+ */
+export interface TopologyInterfaceInput {
+  networkDeviceId: string;
+  interfaceIndex: number;
+  name?: string | undefined;
+  isOperationallyUp?: boolean | undefined;
+  isAdministrativelyUp?: boolean | undefined;
+  utilizationPercent?: number | undefined;
+  inRateMbps?: number | undefined;
+  outRateMbps?: number | undefined;
+  errorsPerSecond?: number | undefined;
+}
+
+/*
+ * A neighbor claim from either discovery protocol, normalized so LLDP and
+ * CDP entries flow through the same match/dedupe/enrich pipeline.
+ */
+interface NeighborClaim {
+  protocol: NetworkTopologyLinkProtocol;
+  matchKey: string | undefined;
+  displayName: string | undefined;
+  localInterfaceIndex: number | undefined;
+  remotePortId: string | undefined;
+  // CDP-only: the platform string the neighbor advertises about itself.
+  remotePlatform: string | undefined;
 }
 
 // A device not seen within this window is treated as not currently up.
@@ -22,20 +59,23 @@ const FRESH_WINDOW_MS: number = 15 * 60 * 1000;
 export default class NetworkTopologyUtil {
   /*
    * Builds the topology graph from every device in a project. Nodes are the
-   * devices; LLDP neighbors that match another device (by sysName or
-   * hostname) become edges, and neighbors that match nothing become
+   * devices; LLDP and CDP neighbors that match another device (by sysName,
+   * hostname or name) become edges, and neighbors that match nothing become
    * lightweight "unmanaged" nodes so links don't dead-end. Edges are
-   * undirected and deduplicated, so a link reported from both ends appears
-   * once.
+   * undirected and deduplicated — a link reported from both ends, or by
+   * both protocols, appears once with the union of what each report knew
+   * (ports, protocols, per-end interface state). When `interfaces` rows are
+   * provided, each edge end whose interface is identifiable carries its
+   * operational state (up/down, utilization, rates).
    */
   public static buildTopology(
     devices: Array<TopologyDeviceInput>,
     now: Date,
+    interfaces: Array<TopologyInterfaceInput> = [],
   ): NetworkTopology {
     const nodes: Array<NetworkTopologyNode> = [];
-    const edges: Array<NetworkTopologyEdge> = [];
 
-    // Index managed devices by the identifiers LLDP neighbors reference.
+    // Index managed devices by the identifiers neighbor entries reference.
     const deviceByMatchKey: Map<string, TopologyDeviceInput> = new Map();
     for (const device of devices) {
       for (const key of NetworkTopologyUtil.matchKeysForDevice(device)) {
@@ -43,6 +83,24 @@ export default class NetworkTopologyUtil {
       }
     }
 
+    // Index interface rows by (device, index) and by (device, name).
+    const interfaceByDeviceAndIndex: Map<string, TopologyInterfaceInput> =
+      new Map();
+    const interfaceByDeviceAndName: Map<string, TopologyInterfaceInput> =
+      new Map();
+    for (const row of interfaces) {
+      interfaceByDeviceAndIndex.set(
+        `${row.networkDeviceId}::${row.interfaceIndex}`,
+        row,
+      );
+      const nameKey: string | undefined = NetworkTopologyUtil.normalizeKey(
+        row.name,
+      );
+      if (nameKey) {
+        interfaceByDeviceAndName.set(`${row.networkDeviceId}::${nameKey}`, row);
+      }
+    }
+
     for (const device of devices) {
       nodes.push({
         id: device.id,
@@ -51,24 +109,24 @@ export default class NetworkTopologyUtil {
         status: NetworkTopologyUtil.deviceStatus(device, now),
         interfacesUp: device.interfacesUp,
         interfacesDown: device.interfacesDown,
+        sysName: device.sysName,
+        vendor: device.vendor,
+        deviceModel: device.deviceModel,
       });
     }
 
-    const unmanagedNodeIds: Set<string> = new Set();
-    const seenEdgeKeys: Set<string> = new Set();
+    const unmanagedNodeById: Map<string, NetworkTopologyNode> = new Map();
+    const edgeByKey: Map<string, NetworkTopologyEdge> = new Map();
 
     for (const device of devices) {
-      for (const neighbor of device.lldpNeighbors || []) {
-        const matchKey: string | undefined =
-          NetworkTopologyUtil.normalizeKey(neighbor.remoteSysName) ||
-          NetworkTopologyUtil.normalizeKey(neighbor.remoteChassisId);
-
-        if (!matchKey) {
+      for (const claim of NetworkTopologyUtil.neighborClaimsForDevice(device)) {
+        if (!claim.matchKey) {
           continue;
         }
 
-        const matched: TopologyDeviceInput | undefined =
-          deviceByMatchKey.get(matchKey);
+        const matched: TopologyDeviceInput | undefined = deviceByMatchKey.get(
+          claim.matchKey,
+        );
 
         let toNodeId: string;
 
@@ -79,58 +137,212 @@ export default class NetworkTopologyUtil {
           }
           toNodeId = matched.id;
         } else {
-          toNodeId = `unmanaged:${matchKey}`;
-          if (!unmanagedNodeIds.has(toNodeId)) {
-            unmanagedNodeIds.add(toNodeId);
-            nodes.push({
+          toNodeId = `unmanaged:${claim.matchKey}`;
+          const existingUnmanaged: NetworkTopologyNode | undefined =
+            unmanagedNodeById.get(toNodeId);
+          if (!existingUnmanaged) {
+            const unmanagedNode: NetworkTopologyNode = {
               id: toNodeId,
-              name:
-                neighbor.remoteSysName ||
-                neighbor.remoteChassisId ||
-                "Unknown device",
+              name: claim.displayName || "Unknown device",
               isManaged: false,
               status: "unknown",
-            });
+              deviceModel: claim.remotePlatform,
+            };
+            unmanagedNodeById.set(toNodeId, unmanagedNode);
+            nodes.push(unmanagedNode);
+          } else if (!existingUnmanaged.deviceModel && claim.remotePlatform) {
+            // A later CDP claim may know the platform the first one didn't.
+            existingUnmanaged.deviceModel = claim.remotePlatform;
+          }
+        }
+
+        // The reporting device's own end, enriched from its interface row.
+        let localEndpoint: NetworkTopologyEdgeEndpoint | undefined = undefined;
+        let localPortLabel: string | undefined = undefined;
+        if (claim.localInterfaceIndex !== undefined) {
+          const localInterface: TopologyInterfaceInput | undefined =
+            interfaceByDeviceAndIndex.get(
+              `${device.id}::${claim.localInterfaceIndex}`,
+            );
+          localEndpoint = {
+            interfaceIndex: claim.localInterfaceIndex,
+            interfaceName: localInterface?.name,
+            isOperationallyUp: localInterface?.isOperationallyUp,
+            isAdministrativelyUp: localInterface?.isAdministrativelyUp,
+            utilizationPercent: localInterface?.utilizationPercent,
+            inRateMbps: localInterface?.inRateMbps,
+            outRateMbps: localInterface?.outRateMbps,
+            errorsPerSecond: localInterface?.errorsPerSecond,
+          };
+          localPortLabel =
+            localInterface?.name || `if${claim.localInterfaceIndex}`;
+        }
+
+        /*
+         * The far end: best-effort — the advertised remote port id often
+         * matches the remote device's interface name (e.g. "GigabitEthernet
+         * 0/1"). Only attach data when it does; a bare port id string stays
+         * in toPort.
+         */
+        let remoteEndpoint: NetworkTopologyEdgeEndpoint | undefined = undefined;
+        if (matched && claim.remotePortId) {
+          const remotePortKey: string | undefined =
+            NetworkTopologyUtil.normalizeKey(claim.remotePortId);
+          const remoteInterface: TopologyInterfaceInput | undefined =
+            remotePortKey
+              ? interfaceByDeviceAndName.get(`${matched.id}::${remotePortKey}`)
+              : undefined;
+          if (remoteInterface) {
+            remoteEndpoint = {
+              interfaceIndex: remoteInterface.interfaceIndex,
+              interfaceName: remoteInterface.name,
+              isOperationallyUp: remoteInterface.isOperationallyUp,
+              isAdministrativelyUp: remoteInterface.isAdministrativelyUp,
+              utilizationPercent: remoteInterface.utilizationPercent,
+              inRateMbps: remoteInterface.inRateMbps,
+              outRateMbps: remoteInterface.outRateMbps,
+              errorsPerSecond: remoteInterface.errorsPerSecond,
+            };
           }
         }
 
         // Undirected dedupe: canonicalize the endpoint pair.
         const edgeKey: string = [device.id, toNodeId].sort().join("::");
-        if (seenEdgeKeys.has(edgeKey)) {
+        const existing: NetworkTopologyEdge | undefined =
+          edgeByKey.get(edgeKey);
+
+        if (!existing) {
+          edgeByKey.set(edgeKey, {
+            fromNodeId: device.id,
+            toNodeId: toNodeId,
+            fromPort: localPortLabel,
+            toPort: claim.remotePortId,
+            protocols: [claim.protocol],
+            fromInterface: localEndpoint,
+            toInterface: remoteEndpoint,
+          });
           continue;
         }
-        seenEdgeKeys.add(edgeKey);
-
-        edges.push({
-          fromNodeId: device.id,
-          toNodeId: toNodeId,
-          fromPort:
-            neighbor.localInterfaceIndex !== undefined
-              ? `if${neighbor.localInterfaceIndex}`
-              : undefined,
-          toPort: neighbor.remotePortId,
-        });
+
+        /*
+         * Same link reported again — from the other end, or by the other
+         * protocol. Merge instead of dropping so both ends keep the best
+         * data anyone reported about them.
+         */
+        if (
+          existing.protocols &&
+          !existing.protocols.includes(claim.protocol)
+        ) {
+          existing.protocols.push(claim.protocol);
+        }
+
+        if (existing.fromNodeId === device.id) {
+          existing.fromPort = existing.fromPort || localPortLabel;
+          existing.toPort = existing.toPort || claim.remotePortId;
+          existing.fromInterface = NetworkTopologyUtil.mergeEndpoints(
+            existing.fromInterface,
+            localEndpoint,
+          );
+          existing.toInterface = NetworkTopologyUtil.mergeEndpoints(
+            existing.toInterface,
+            remoteEndpoint,
+          );
+        } else {
+          existing.toPort = existing.toPort || localPortLabel;
+          existing.fromPort = existing.fromPort || claim.remotePortId;
+          existing.toInterface = NetworkTopologyUtil.mergeEndpoints(
+            existing.toInterface,
+            localEndpoint,
+          );
+          existing.fromInterface = NetworkTopologyUtil.mergeEndpoints(
+            existing.fromInterface,
+            remoteEndpoint,
+          );
+        }
       }
     }
 
-    return { nodes, edges };
+    return { nodes, edges: Array.from(edgeByKey.values()) };
+  }
+
+  /*
+   * Both protocols' neighbor entries, normalized. LLDP first so its
+   * (usually richer) identifiers win the first-report slots; CDP then
+   * fills gaps or dedupes into the same edge.
+   */
+  private static neighborClaimsForDevice(
+    device: TopologyDeviceInput,
+  ): Array<NeighborClaim> {
+    const claims: Array<NeighborClaim> = [];
+
+    for (const neighbor of device.lldpNeighbors || []) {
+      claims.push({
+        protocol: "lldp",
+        matchKey:
+          NetworkTopologyUtil.normalizeKey(neighbor.remoteSysName) ||
+          NetworkTopologyUtil.normalizeKey(neighbor.remoteChassisId),
+        displayName: neighbor.remoteSysName || neighbor.remoteChassisId,
+        localInterfaceIndex: neighbor.localInterfaceIndex,
+        remotePortId: neighbor.remotePortId,
+        remotePlatform: undefined,
+      });
+    }
+
+    for (const neighbor of device.cdpNeighbors || []) {
+      claims.push({
+        protocol: "cdp",
+        matchKey: NetworkTopologyUtil.normalizeKey(neighbor.remoteDeviceId),
+        displayName: neighbor.remoteDeviceId,
+        localInterfaceIndex: neighbor.localInterfaceIndex,
+        remotePortId: neighbor.remotePortId,
+        remotePlatform: neighbor.remotePlatform,
+      });
+    }
+
+    return claims;
+  }
+
+  // Existing fields win; the incoming report only fills what's missing.
+  private static mergeEndpoints(
+    existing: NetworkTopologyEdgeEndpoint | undefined,
+    incoming: NetworkTopologyEdgeEndpoint | undefined,
+  ): NetworkTopologyEdgeEndpoint | undefined {
+    if (!existing) {
+      return incoming;
+    }
+    if (!incoming) {
+      return existing;
+    }
+    return {
+      interfaceIndex: existing.interfaceIndex ?? incoming.interfaceIndex,
+      interfaceName: existing.interfaceName ?? incoming.interfaceName,
+      isOperationallyUp:
+        existing.isOperationallyUp ?? incoming.isOperationallyUp,
+      isAdministrativelyUp:
+        existing.isAdministrativelyUp ?? incoming.isAdministrativelyUp,
+      utilizationPercent:
+        existing.utilizationPercent ?? incoming.utilizationPercent,
+      inRateMbps: existing.inRateMbps ?? incoming.inRateMbps,
+      outRateMbps: existing.outRateMbps ?? incoming.outRateMbps,
+      errorsPerSecond: existing.errorsPerSecond ?? incoming.errorsPerSecond,
+    };
   }
 
   private static matchKeysForDevice(
     device: TopologyDeviceInput,
   ): Array<string> {
+    /*
+     * sysName / hostname / name — the identifiers LLDP remoteSysName and
+     * CDP remoteDeviceId advertise. Order matters only across devices
+     * (last writer wins on a collision), not within one device.
+     */
     const keys: Array<string> = [];
-    const sysNameKey: string | undefined = NetworkTopologyUtil.normalizeKey(
-      device.sysName,
-    );
-    const hostnameKey: string | undefined = NetworkTopologyUtil.normalizeKey(
-      device.hostname,
-    );
-    if (sysNameKey) {
-      keys.push(sysNameKey);
-    }
-    if (hostnameKey) {
-      keys.push(hostnameKey);
+    for (const candidate of [device.sysName, device.hostname, device.name]) {
+      const key: string | undefined =
+        NetworkTopologyUtil.normalizeKey(candidate);
+      if (key && !keys.includes(key)) {
+        keys.push(key);
+      }
     }
     return keys;
   }

package/Utils/ValueFormatter.ts

@@ -292,7 +292,28 @@ function formatNumber(value: number): string {
     return (Math.round(value * 10) / 10).toString();
   }
 
-  return (Math.round(value * 100) / 100).toString();
+  if (absValue >= 1) {
+    return (Math.round(value * 100) / 100).toString();
+  }
+
+  /*
+   * Below 1, fixed two-decimal rounding collapses distinct values onto the
+   * same label (0.004 and 0.006 both become "0.01"), which renders chart
+   * axes with runs of duplicate ticks. Two significant digits keeps
+   * neighbouring ticks distinct at any magnitude.
+   */
+  const rounded: number = parseFloat(value.toPrecision(2));
+  const asString: string = rounded.toString();
+  if (!asString.includes("e") && !asString.includes("E")) {
+    return asString;
+  }
+
+  /*
+   * Number.prototype.toString switches to exponential notation below 1e-6
+   * ("1.2e-7"), which is unreadable on an axis label — expand it back to
+   * plain decimals and trim the trailing zeros toFixed pads with.
+   */
+  return rounded.toFixed(20).replace(/0+$/, "").replace(/\.$/, "");
 }
 
 /*

package/build/dist/Models/AnalyticsModels/Index.js

@@ -2,10 +2,14 @@ import Log from "./Log";
 import Metric from "./Metric";
 import MetricItemAggMV1m from "./MetricItemAggMV1m";
 import MetricItemAggMV1mByHostV2 from "./MetricItemAggMV1mByHostV2";
+import MetricItemAggMV1mByService from "./MetricItemAggMV1mByService";
+import MetricItemAggMV1mByK8sCluster from "./MetricItemAggMV1mByK8sCluster";
+import MetricItemAggMV1mByContainer from "./MetricItemAggMV1mByContainer";
 import MetricBaselineHourly from "./MetricBaselineHourly";
 import Span from "./Span";
 import ExceptionInstance from "./ExceptionInstance";
 import MonitorLog from "./MonitorLog";
+import NetworkFlow from "./NetworkFlow";
 import Profile from "./Profile";
 import ProfileSample from "./ProfileSample";
 import AuditLog from "./AuditLog";
@@ -24,9 +28,18 @@ const AnalyticsModels = [
      * boot-time schema sync doesn't resurrect the dropped V1 table.
      */
     MetricItemAggMV1mByHostV2,
+    /*
+     * Entity-keyed siblings of the host rollup (serviceEntityKey /
+     * k8sClusterEntityKey / containerEntityKey), serving the other
+     * entity-scoped chart paths in MetricService.
+     */
+    MetricItemAggMV1mByService,
+    MetricItemAggMV1mByK8sCluster,
+    MetricItemAggMV1mByContainer,
     MetricBaselineHourly,
     ExceptionInstance,
     MonitorLog,
+    NetworkFlow,
     Profile,
     ProfileSample,
     AuditLog,

package/build/dist/Models/AnalyticsModels/Index.js.map

@@ -1 +1 @@
-{"version":3,"file":"Index.js","sourceRoot":"","sources":["../../../../Models/AnalyticsModels/Index.ts"],"names":[],"mappings":"AACA,OAAO,GAAG,MAAM,OAAO,CAAC;AACxB,OAAO,MAAM,MAAM,UAAU,CAAC;AAC9B,OAAO,iBAAiB,MAAM,qBAAqB,CAAC;AACpD,OAAO,yBAAyB,MAAM,6BAA6B,CAAC;AACpE,OAAO,oBAAoB,MAAM,wBAAwB,CAAC;AAC1D,OAAO,IAAI,MAAM,QAAQ,CAAC;AAC1B,OAAO,iBAAiB,MAAM,qBAAqB,CAAC;AACpD,OAAO,UAAU,MAAM,cAAc,CAAC;AACtC,OAAO,OAAO,MAAM,WAAW,CAAC;AAChC,OAAO,aAAa,MAAM,iBAAiB,CAAC;AAC5C,OAAO,QAAQ,MAAM,YAAY,CAAC;AAElC,MAAM,eAAe,GAA0C;IAC7D,GAAG;IACH,IAAI;IACJ,MAAM;IACN;;;OAGG;IACH,iBAAiB;IACjB;;;;OAIG;IACH,yBAAyB;IACzB,oBAAoB;IACpB,iBAAiB;IACjB,UAAU;IACV,OAAO;IACP,aAAa;IACb,QAAQ;CACT,CAAC;AAEF,MAAM,YAAY,GAAsD,EAAE,CAAC;AAM3E,MAAM,CAAC,MAAM,kBAAkB,GAAuB,CACpD,SAAiB,EACsB,EAAE;IACzC,IAAI,YAAY,CAAC,SAAS,CAAC,EAAE,CAAC;QAC5B,OAAO,YAAY,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC;IACzC,CAAC;IAED,MAAM,SAAS,GACb,eAAe,CAAC,IAAI,CAAC,CAAC,SAAyC,EAAE,EAAE;QACjE,OAAO,IAAI,SAAS,EAAE,CAAC,SAAS,KAAK,SAAS,CAAC;IACjD,CAAC,CAAC,CAAC;IAEL,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,OAAO,IAAI,CAAC;IACd,CAAC;IAED,YAAY,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC;IAEpC,OAAO,SAAS,CAAC;AACnB,CAAC,CAAC;AAEF,eAAe,eAAe,CAAC"}
+{"version":3,"file":"Index.js","sourceRoot":"","sources":["../../../../Models/AnalyticsModels/Index.ts"],"names":[],"mappings":"AACA,OAAO,GAAG,MAAM,OAAO,CAAC;AACxB,OAAO,MAAM,MAAM,UAAU,CAAC;AAC9B,OAAO,iBAAiB,MAAM,qBAAqB,CAAC;AACpD,OAAO,yBAAyB,MAAM,6BAA6B,CAAC;AACpE,OAAO,0BAA0B,MAAM,8BAA8B,CAAC;AACtE,OAAO,6BAA6B,MAAM,iCAAiC,CAAC;AAC5E,OAAO,4BAA4B,MAAM,gCAAgC,CAAC;AAC1E,OAAO,oBAAoB,MAAM,wBAAwB,CAAC;AAC1D,OAAO,IAAI,MAAM,QAAQ,CAAC;AAC1B,OAAO,iBAAiB,MAAM,qBAAqB,CAAC;AACpD,OAAO,UAAU,MAAM,cAAc,CAAC;AACtC,OAAO,WAAW,MAAM,eAAe,CAAC;AACxC,OAAO,OAAO,MAAM,WAAW,CAAC;AAChC,OAAO,aAAa,MAAM,iBAAiB,CAAC;AAC5C,OAAO,QAAQ,MAAM,YAAY,CAAC;AAElC,MAAM,eAAe,GAA0C;IAC7D,GAAG;IACH,IAAI;IACJ,MAAM;IACN;;;OAGG;IACH,iBAAiB;IACjB;;;;OAIG;IACH,yBAAyB;IACzB;;;;OAIG;IACH,0BAA0B;IAC1B,6BAA6B;IAC7B,4BAA4B;IAC5B,oBAAoB;IACpB,iBAAiB;IACjB,UAAU;IACV,WAAW;IACX,OAAO;IACP,aAAa;IACb,QAAQ;CACT,CAAC;AAEF,MAAM,YAAY,GAAsD,EAAE,CAAC;AAM3E,MAAM,CAAC,MAAM,kBAAkB,GAAuB,CACpD,SAAiB,EACsB,EAAE;IACzC,IAAI,YAAY,CAAC,SAAS,CAAC,EAAE,CAAC;QAC5B,OAAO,YAAY,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC;IACzC,CAAC;IAED,MAAM,SAAS,GACb,eAAe,CAAC,IAAI,CAAC,CAAC,SAAyC,EAAE,EAAE;QACjE,OAAO,IAAI,SAAS,EAAE,CAAC,SAAS,KAAK,SAAS,CAAC;IACjD,CAAC,CAAC,CAAC;IAEL,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,OAAO,IAAI,CAAC;IACd,CAAC;IAED,YAAY,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC;IAEpC,OAAO,SAAS,CAAC;AACnB,CAAC,CAAC;AAEF,eAAe,eAAe,CAAC"}

package/build/dist/Models/AnalyticsModels/MetricItemAggMV1mByContainer.js

@@ -0,0 +1,159 @@
+import AnalyticsBaseModel from "./AnalyticsBaseModel/AnalyticsBaseModel";
+import AnalyticsTableEngine from "../../Types/AnalyticsDatabase/AnalyticsTableEngine";
+import AnalyticsTableName from "../../Types/AnalyticsDatabase/AnalyticsTableName";
+import AnalyticsTableColumn from "../../Types/AnalyticsDatabase/TableColumn";
+import TableColumnType from "../../Types/AnalyticsDatabase/TableColumnType";
+/**
+ * Per-(container, minute) pre-aggregated rollup of `MetricItemV3` value
+ * samples — sibling of `MetricItemAggMV1mByHostV2`, keyed by the stable
+ * 16-hex `containerEntityKey` the ingest pipeline stamps on every row
+ * whose resource carries a container identity. Container identity is
+ * `container.id` ONLY (see the container resolver in
+ * Common/Server/Utils/Telemetry/TelemetryEntity), so the read side can
+ * derive the key directly from the incoming `resource.container.id`
+ * filter via `keyForContainer` — no registry lookup needed (containers
+ * are a membership-only entity type that never mints registry rows).
+ *
+ * Populated by `MetricItemAggMV1mByContainer_mv` (declared below;
+ * created idempotently by boot schema-sync — the service is registered
+ * in AnalyticsServices — and backfilled from `MetricItemV3` by the
+ * AddMetricEntityMinuteAggregateMaterializedViews migration). Rows whose
+ * resource carries no container entity (`containerEntityKey = ''`) are
+ * filtered out so the rollup stays small.
+ *
+ * Read access goes through
+ * `MetricService.tryBuildEntityAggregateMVStatement` for single
+ * `resource.container.id` equality filters.
+ *
+ * No CRUD API; read-only infrastructure populated entirely by the MV.
+ */
+export default class MetricItemAggMV1mByContainer extends AnalyticsBaseModel {
+    constructor() {
+        const projectIdColumn = new AnalyticsTableColumn({
+            key: "projectId",
+            title: "Project ID",
+            description: "ID of project (tenant key, replicated from MetricItemV3)",
+            required: true,
+            type: TableColumnType.Text,
+            isTenantId: true,
+        });
+        const nameColumn = new AnalyticsTableColumn({
+            key: "name",
+            title: "Metric Name",
+            description: "Metric name (replicated from MetricItemV3)",
+            required: true,
+            type: TableColumnType.Text,
+        });
+        const containerEntityKeyColumn = new AnalyticsTableColumn({
+            key: "containerEntityKey",
+            title: "Container Entity Key",
+            description: "Stable 16-hex container entity key (keyForContainer — container.id only) replicated from MetricItemV3.containerEntityKey at insert time. Rows without one are filtered out by the MV's WHERE clause so this column is always populated for rows that exist.",
+            required: true,
+            type: TableColumnType.Text,
+        });
+        const bucketTimeColumn = new AnalyticsTableColumn({
+            key: "bucketTime",
+            title: "Bucket Time",
+            description: "Start of the 1-minute bucket this row aggregates. Computed by the MV as toStartOfMinute(time).",
+            required: true,
+            type: TableColumnType.Date,
+        });
+        const valueSumStateColumn = new AnalyticsTableColumn({
+            key: "valueSumState",
+            title: "Sum (state)",
+            description: "AggregateFunction(sum, Float64) state for valueSum. Read via sumMerge(valueSumState).",
+            required: true,
+            type: TableColumnType.AggregateFunction,
+            aggregateFunctionDefinition: "sum, Float64",
+        });
+        const valueCountStateColumn = new AnalyticsTableColumn({
+            key: "valueCountState",
+            title: "Count (state)",
+            description: "AggregateFunction(count, Float64) state for valueCount. Read via countMerge(valueCountState).",
+            required: true,
+            type: TableColumnType.AggregateFunction,
+            aggregateFunctionDefinition: "count, Float64",
+        });
+        const valueMinStateColumn = new AnalyticsTableColumn({
+            key: "valueMinState",
+            title: "Min (state)",
+            description: "AggregateFunction(min, Float64) state. Read via minMerge(valueMinState).",
+            required: true,
+            type: TableColumnType.AggregateFunction,
+            aggregateFunctionDefinition: "min, Float64",
+        });
+        const valueMaxStateColumn = new AnalyticsTableColumn({
+            key: "valueMaxState",
+            title: "Max (state)",
+            description: "AggregateFunction(max, Float64) state. Read via maxMerge(valueMaxState).",
+            required: true,
+            type: TableColumnType.AggregateFunction,
+            aggregateFunctionDefinition: "max, Float64",
+        });
+        const retentionDateColumn = new AnalyticsTableColumn({
+            key: "retentionDate",
+            title: "Retention Date",
+            description: "Date after which this row is eligible for TTL deletion. Computed by the MV as max(retentionDate) per bucket — inherits from the source MetricItemV3 rows.",
+            required: true,
+            type: TableColumnType.Date,
+        });
+        super({
+            tableName: AnalyticsTableName.MetricItemAggMV1mByContainer,
+            tableEngine: AnalyticsTableEngine.AggregatingMergeTree,
+            singularName: "Metric 1-Minute Aggregate (By Container Entity Key)",
+            pluralName: "Metric 1-Minute Aggregates (By Container Entity Key)",
+            tableColumns: [
+                projectIdColumn,
+                nameColumn,
+                containerEntityKeyColumn,
+                bucketTimeColumn,
+                valueSumStateColumn,
+                valueCountStateColumn,
+                valueMinStateColumn,
+                valueMaxStateColumn,
+                retentionDateColumn,
+            ],
+            projections: [],
+            /*
+             * Per-container materialized view, reading the ingest-stamped
+             * `containerEntityKey` scalar column (contract C3) rather than the
+             * raw attributes map. Canonical definition; created idempotently by
+             * the analytics schema-sync on boot
+             * (MetricItemAggMV1mByContainerService is registered in
+             * AnalyticsServices, so a wiped ClickHouse volume self-heals) and
+             * backfilled by the AddMetricEntityMinuteAggregateMaterializedViews
+             * migration. Rows without a container entity are filtered out so
+             * the per-container MV stays small.
+             */
+            materializedViews: [
+                {
+                    name: "MetricItemAggMV1mByContainer_mv",
+                    query: `CREATE MATERIALIZED VIEW IF NOT EXISTS MetricItemAggMV1mByContainer_mv
+TO MetricItemAggMV1mByContainer
+AS
+SELECT
+  projectId,
+  name,
+  containerEntityKey,
+  toStartOfMinute(time) AS bucketTime,
+  sumState(toFloat64(coalesce(value, sum, 0))) AS valueSumState,
+  countState(toFloat64(coalesce(value, sum, 0))) AS valueCountState,
+  minState(toFloat64(coalesce(value, sum, 0))) AS valueMinState,
+  maxState(toFloat64(coalesce(value, sum, 0))) AS valueMaxState,
+  max(retentionDate) AS retentionDate
+FROM MetricItemV3
+WHERE containerEntityKey != ''
+GROUP BY projectId, name, containerEntityKey, bucketTime`,
+                },
+            ],
+            sortKeys: ["projectId", "name", "containerEntityKey", "bucketTime"],
+            primaryKeys: ["projectId", "name", "containerEntityKey", "bucketTime"],
+            partitionKey: "toYYYYMM(bucketTime)",
+            // Align with this MV's GROUP BY (projectId, name, containerEntityKey).
+            shardingKey: "cityHash64(projectId, name, containerEntityKey)",
+            tableSettings: "ttl_only_drop_parts = 1, non_replicated_deduplication_window = 10000",
+            ttlExpression: "retentionDate DELETE",
+        });
+    }
+}
+//# sourceMappingURL=MetricItemAggMV1mByContainer.js.map

package/build/dist/Models/AnalyticsModels/MetricItemAggMV1mByContainer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetricItemAggMV1mByContainer.js","sourceRoot":"","sources":["../../../../Models/AnalyticsModels/MetricItemAggMV1mByContainer.ts"],"names":[],"mappings":"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"}