@oneuptime/common 12.0.12 → 12.0.14

package/Utils/API.ts

@@ -226,8 +226,13 @@ export default class API {
   }
 
   public static getDefaultHeaders(_props?: any): Headers {
+    /*
+     * NOTE: no "Access-Control-Allow-Origin" here - that is a RESPONSE-only
+     * header. Sending it as a request header forces a CORS preflight on every
+     * cross-origin call (self-hosted setups where the API is on a different
+     * origin), doubling the request count for zero benefit.
+     */
     const defaultHeaders: Headers = {
-      "Access-Control-Allow-Origin": "*",
       Accept: "application/json",
       "Content-Type": "application/json;charset=UTF-8",
     };

package/Utils/Monitor/MonitorMetricType.ts

@@ -1,7 +1,9 @@
 import AggregationType from "../../Types/BaseDatabase/AggregationType";
 import { CheckOn } from "../../Types/Monitor/CriteriaFilter";
 import MonitorMetricType from "../../Types/Monitor/MonitorMetricType";
-import MonitorType from "../../Types/Monitor/MonitorType";
+import MonitorType, {
+  MonitorTypeHelper,
+} from "../../Types/Monitor/MonitorType";
 
 /*
  * Groups of metrics rendered as separate cards on the monitor metrics page.
@@ -238,11 +240,24 @@ class MonitorMetricTypeUtil {
       monitorType === MonitorType.DNSSEC ||
       monitorType === MonitorType.Domain ||
       monitorType === MonitorType.SQLQuery ||
+      monitorType === MonitorType.SSLCertificate ||
       monitorType === MonitorType.ExternalStatusPage
     ) {
       return [MonitorMetricType.IsOnline, MonitorMetricType.ResponseTime];
     }
 
+    /*
+     * Any other type the probe actually checks still writes IsOnline and
+     * ResponseTime rows, so default to showing them rather than to an empty
+     * list. Falling through to [] hides the Monitor Metrics tab entirely -
+     * SSL Certificate monitors were missing from the list above and so had
+     * no metrics tab at all, which left an operator with no way to see that
+     * their monitor was running.
+     */
+    if (MonitorTypeHelper.isProbableMonitor(monitorType)) {
+      return [MonitorMetricType.IsOnline, MonitorMetricType.ResponseTime];
+    }
+
     return [];
   }
 

package/Utils/Monitor/NetworkTopologyUtil.ts

@@ -13,13 +13,27 @@ import {
   classifyEndpointRole,
   resolveDeviceRole,
 } from "./NetworkDeviceRoleUtil";
+import DeviceReachabilityUtil, {
+  NetworkDeviceReachability,
+} from "../NetworkDevice/DeviceReachabilityUtil";
 
 export interface TopologyDeviceInput {
   id: string;
   name: string;
   hostname?: string | undefined;
   sysName?: string | undefined;
+  /*
+   * Reachability inputs, all three of them. `isReachable` is the outcome of
+   * the last poll and is what actually decides up/down; `lastPolledAt` and
+   * `pollingIntervalInMinutes` only size the "we have stopped polling
+   * entirely" backstop. Passing lastSeenAt alone still works (that is the
+   * legacy path for rows written before the columns existed) but re-creates
+   * the bug where a fleet the probe cannot keep up with draws all-red.
+   */
+  isReachable?: boolean | undefined;
+  lastPolledAt?: Date | undefined;
   lastSeenAt?: Date | undefined;
+  pollingIntervalInMinutes?: number | undefined;
   interfacesUp?: number | undefined;
   interfacesDown?: number | undefined;
   vendor?: string | undefined;
@@ -232,12 +246,17 @@ interface ResolvedClaim {
  */
 const IPV4_PATTERN: RegExp = /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
 
-// A device not seen within this window is treated as not currently up.
-const FRESH_WINDOW_MS: number = 15 * 60 * 1000;
-
 // Endpoint nodes rendered per graph; the slice is deterministic (by MAC).
 const ENDPOINT_RENDER_CAP: number = 2000;
 
+/*
+ * How long an ARP/FDB-learned endpoint keeps its "up" colour after the last
+ * walk that saw it. Taken from the shared device rule at its default
+ * interval so the map's two node kinds age out on comparable timescales.
+ */
+const ENDPOINT_FRESH_WINDOW_MS: number =
+  DeviceReachabilityUtil.getStaleWindowInMinutes(undefined) * 60 * 1000;
+
 export default class NetworkTopologyUtil {
   /*
    * Builds the topology graph from every device in a project. Nodes are the
@@ -1305,10 +1324,17 @@ export default class NetworkTopologyUtil {
     if (device.monitorStatus) {
       return device.monitorStatus;
     }
-    return NetworkTopologyUtil.statusFromLastSeen(device.lastSeenAt, now);
+    return NetworkTopologyUtil.statusFromPoll(device, now);
   }
 
-  // The shared freshness rule: seen within the window = up, stale = down.
+  /*
+   * Endpoints (ARP/FDB-learned hosts) have no poll of their own: they are
+   * re-learned from whichever device's tables they appear in, so freshness
+   * really is all there is to go on. The window is the shared default
+   * staleness window rather than the old fixed 15 minutes, so a host on a
+   * switch its probe polls slowly does not blink out of the map between
+   * walks.
+   */
   private static statusFromLastSeen(
     lastSeenAt: Date | undefined,
     now: Date,
@@ -1316,10 +1342,36 @@ export default class NetworkTopologyUtil {
     if (!lastSeenAt) {
       return "unknown";
     }
+
     const ageMs: number = now.getTime() - new Date(lastSeenAt).getTime();
-    if (ageMs > FRESH_WINDOW_MS) {
-      return "down";
+
+    return ageMs > ENDPOINT_FRESH_WINDOW_MS ? "down" : "up";
+  }
+
+  /*
+   * The shared reachability rule (DeviceReachabilityUtil), mapped onto the
+   * graph's three node states. "Pending" — never polled — is the graph's
+   * "unknown", which is what keeps a device nothing walks from being drawn
+   * as a failure.
+   */
+  private static statusFromPoll(
+    device: TopologyDeviceInput,
+    now: Date,
+  ): NetworkTopologyNodeStatus {
+    const status: NetworkDeviceReachability = DeviceReachabilityUtil.getStatus(
+      {
+        isReachable: device.isReachable,
+        lastPolledAt: device.lastPolledAt,
+        lastSeenAt: device.lastSeenAt,
+        pollingIntervalInMinutes: device.pollingIntervalInMinutes,
+      },
+      now,
+    );
+
+    if (status === NetworkDeviceReachability.Pending) {
+      return "unknown";
     }
-    return "up";
+
+    return status === NetworkDeviceReachability.Up ? "up" : "down";
   }
 }

package/Utils/NetworkDevice/DeviceReachabilityUtil.ts

@@ -0,0 +1,262 @@
+import OneUptimeDate from "../../Types/Date";
+
+/*
+ * The one place that decides whether a NetworkDevice is reachable.
+ *
+ * The rule this replaces was "lastSeenAt within a fixed 15 minutes = up",
+ * which conflates two different facts:
+ *
+ *   1. the device did not answer the probe   (the device is down), and
+ *   2. the probe has not asked it recently   (WE are behind).
+ *
+ * (2) is not a device outage. A probe hands out at most a bounded number of
+ * devices per fetch cycle, so a large fleet's real poll cadence is
+ * `fleetSize / claimRate` minutes however short the configured interval is —
+ * and a fleet whose cadence exceeds the freshness window paints healthy
+ * devices red on the device list, the topology graph and the site rollup,
+ * while the device's own Interfaces tab (written by that same successful
+ * walk) still reads "Up". A device polled on a 30-minute interval was
+ * permanently "Down" for the same reason: it can never satisfy a 15-minute
+ * window.
+ *
+ * So reachability is now the OUTCOME of the most recent poll —
+ * NetworkDevice.isReachable, stamped by the walk pipeline on every ingested
+ * walk — and freshness is only a backstop for "the polling pipeline itself
+ * stopped", measured generously against the device's own interval.
+ */
+
+export enum NetworkDeviceReachability {
+  Up = "Up",
+  Down = "Down",
+  Pending = "Pending",
+}
+
+/*
+ * Mirrors the NetworkDevice.pollingIntervalInMinutes column default, and is
+ * what a NULL interval (rows written before that column existed) is read as.
+ */
+export const DEFAULT_DEVICE_POLLING_INTERVAL_IN_MINUTES: number = 5;
+
+/*
+ * Consecutive missed polls before a device's last verdict is reported as
+ * STALE. Staleness is an annotation on the verdict, never the verdict
+ * itself — see getReachability for why turning it into "Down" would both
+ * re-create this bug at a longer timescale and put the pill permanently at
+ * odds with the summary counts.
+ *
+ * Deliberately generous: a device that stops answering is marked
+ * unreachable by the very next poll, so the only thing this flags is the
+ * whole polling pipeline going silent (probe offline, claim loop wedged,
+ * walk queue backed up). Ten missed cycles is unambiguous.
+ */
+export const DEVICE_MISSED_POLL_ALLOWANCE: number = 10;
+
+/*
+ * Floor under the window above, so a device on a one-minute interval is not
+ * declared out of contact after ten minutes of ordinary scheduling jitter.
+ */
+export const DEVICE_MIN_STALE_WINDOW_IN_MINUTES: number = 60;
+
+// The columns this util reads. Every caller selects exactly these.
+export interface DeviceReachabilityInput {
+  /*
+   * Outcome of the most recent poll: true = the device answered, false = the
+   * probe could not reach it, null/undefined = never polled, or a row
+   * written before this column existed.
+   */
+  isReachable?: boolean | null | undefined;
+  // When the probe last ATTEMPTED a walk, whatever the outcome.
+  lastPolledAt?: Date | string | null | undefined;
+  // When the device last ANSWERED one.
+  lastSeenAt?: Date | string | null | undefined;
+  // The device's own schedule; sizes the staleness backstop.
+  pollingIntervalInMinutes?: number | null | undefined;
+}
+
+export interface DeviceReachabilityResult {
+  status: NetworkDeviceReachability;
+  /*
+   * True when the last poll ATTEMPT is older than the staleness window —
+   * i.e. this verdict is being read off data nothing has refreshed for a
+   * long time. Strictly independent of `status`: it qualifies the verdict
+   * ("and nobody has checked lately") rather than changing it, and either
+   * an Up or a Down device can be stale.
+   */
+  isStale: boolean;
+  // The window `isStale` was measured against, so the UI can name it.
+  staleWindowInMinutes: number;
+  // Latest of lastPolledAt / lastSeenAt; null when neither is set.
+  lastContactAt: Date | null;
+}
+
+const MS_PER_MINUTE: number = 60 * 1000;
+
+export default class DeviceReachabilityUtil {
+  /*
+   * The device's poll interval as a usable positive number. NULL, zero,
+   * negative and non-finite values all fall back to the column default —
+   * the same clamp NetworkDeviceService.claimDevicesForPolling applies when
+   * it advances nextPollAt, so the window and the schedule agree.
+   */
+  public static getPollingIntervalInMinutes(
+    pollingIntervalInMinutes?: number | null | undefined,
+  ): number {
+    if (
+      typeof pollingIntervalInMinutes !== "number" ||
+      !Number.isFinite(pollingIntervalInMinutes) ||
+      pollingIntervalInMinutes <= 0
+    ) {
+      return DEFAULT_DEVICE_POLLING_INTERVAL_IN_MINUTES;
+    }
+
+    return Math.max(pollingIntervalInMinutes, 1);
+  }
+
+  // How long a device may go unpolled before its last verdict goes stale.
+  public static getStaleWindowInMinutes(
+    pollingIntervalInMinutes?: number | null | undefined,
+  ): number {
+    const interval: number = DeviceReachabilityUtil.getPollingIntervalInMinutes(
+      pollingIntervalInMinutes,
+    );
+
+    return Math.max(
+      interval * DEVICE_MISSED_POLL_ALLOWANCE,
+      DEVICE_MIN_STALE_WINDOW_IN_MINUTES,
+    );
+  }
+
+  public static getReachability(
+    device: DeviceReachabilityInput,
+    now?: Date | undefined,
+  ): DeviceReachabilityResult {
+    const currentDate: Date = now || OneUptimeDate.getCurrentDate();
+
+    const staleWindowInMinutes: number =
+      DeviceReachabilityUtil.getStaleWindowInMinutes(
+        device.pollingIntervalInMinutes,
+      );
+
+    const lastPolledAt: Date | null = toDate(device.lastPolledAt);
+    const lastSeenAt: Date | null = toDate(device.lastSeenAt);
+
+    /*
+     * Newest of the two. lastPolledAt alone would be wrong for rows written
+     * before it existed (they only have lastSeenAt), and lastSeenAt alone
+     * would call a device that is being polled and failing "out of contact"
+     * — it is very much in contact, it is just down.
+     */
+    const lastContactAt: Date | null = newerOf(lastPolledAt, lastSeenAt);
+
+    const isStale: boolean = lastContactAt
+      ? currentDate.getTime() - lastContactAt.getTime() >
+        staleWindowInMinutes * MS_PER_MINUTE
+      : false;
+
+    const result: (
+      status: NetworkDeviceReachability,
+    ) => DeviceReachabilityResult = (
+      status: NetworkDeviceReachability,
+    ): DeviceReachabilityResult => {
+      return {
+        status: status,
+        isStale: isStale,
+        staleWindowInMinutes: staleWindowInMinutes,
+        lastContactAt: lastContactAt,
+      };
+    };
+
+    /*
+     * The probe asked and got nothing. Authoritative however long ago it
+     * was — nothing since has said otherwise.
+     */
+    if (device.isReachable === false) {
+      return result(NetworkDeviceReachability.Down);
+    }
+
+    /*
+     * The probe asked and the device answered. The answer stands until a
+     * later poll contradicts it.
+     *
+     * Staleness deliberately does NOT override this. Turning "we have not
+     * asked in a while" into "the device is down" is the exact move this
+     * whole change exists to undo — doing it again at a longer timescale
+     * would just relocate the bug. It is also not expressible as a database
+     * filter (the window is per-device, derived from each row's own
+     * interval), so a status that depended on it could never agree with the
+     * summary counts or the Status filter, which have to run in SQL over
+     * `isReachable`. A verdict the list cannot count or filter by is a
+     * verdict that contradicts itself on screen.
+     *
+     * `isStale` still comes back in the result, and the UI shows it as what
+     * it is — "nothing has polled this device in N minutes, check its
+     * probe" — which is a different and more actionable statement than
+     * "this device is down".
+     */
+    if (device.isReachable === true) {
+      return result(NetworkDeviceReachability.Up);
+    }
+
+    /*
+     * No recorded outcome. Either the device has genuinely never been polled
+     * (Pending), or the row predates the column — in which case lastSeenAt
+     * is all we have and freshness is the only rule available. The upgrade
+     * migration backfills these, so this is a short-lived path.
+     */
+    if (!lastSeenAt) {
+      /*
+       * Polled but never once answered — the probe has been trying and
+       * failing, which is Down, not "not set up yet".
+       */
+      if (lastPolledAt) {
+        return result(NetworkDeviceReachability.Down);
+      }
+
+      return result(NetworkDeviceReachability.Pending);
+    }
+
+    return result(
+      isStale ? NetworkDeviceReachability.Down : NetworkDeviceReachability.Up,
+    );
+  }
+
+  // Shorthand for callers that only render the pill.
+  public static getStatus(
+    device: DeviceReachabilityInput,
+    now?: Date | undefined,
+  ): NetworkDeviceReachability {
+    return DeviceReachabilityUtil.getReachability(device, now).status;
+  }
+}
+
+/*
+ * Tolerant of everything an API payload can carry in a date column: a Date,
+ * an ISO string, the serialized {_type, value} form, null, undefined and the
+ * empty string. Anything unparseable reads as "not set" rather than as an
+ * Invalid Date that would silently compare false against every window.
+ */
+function toDate(value: Date | string | null | undefined): Date | null {
+  if (value === null || value === undefined || value === "") {
+    return null;
+  }
+
+  const parsed: Date = OneUptimeDate.fromString(value);
+
+  if (!(parsed instanceof Date) || Number.isNaN(parsed.getTime())) {
+    return null;
+  }
+
+  return parsed;
+}
+
+function newerOf(first: Date | null, second: Date | null): Date | null {
+  if (!first) {
+    return second;
+  }
+
+  if (!second) {
+    return first;
+  }
+
+  return first.getTime() >= second.getTime() ? first : second;
+}

package/Utils/NetworkSite/SiteStatusRollupUtil.ts

@@ -1,3 +1,7 @@
+import DeviceReachabilityUtil, {
+  NetworkDeviceReachability,
+} from "../NetworkDevice/DeviceReachabilityUtil";
+
 /*
  * Worst-of health rollup for a NetworkSite's device subtree.
  *
@@ -16,8 +20,17 @@ export interface DeviceHealthState {
   currentMonitorStatusId?: string | null | undefined;
   // Priority of that status row; missing when the row no longer exists.
   monitorStatusPriority?: number | null | undefined;
-  // Last SNMP contact; drives the freshness fallback for unmonitored devices.
+  /*
+   * The SNMP fallback for devices no monitor stamps, resolved by the shared
+   * DeviceReachabilityUtil rule: the OUTCOME of the last poll, not the age
+   * of the last success. Rolling a site up from freshness alone is what
+   * turned "the probe is behind on a 900-device fleet" into a red site card
+   * over devices that were all answering.
+   */
+  isReachable?: boolean | null | undefined;
+  lastPolledAt?: Date | null | undefined;
   lastSeenAt?: Date | null | undefined;
+  pollingIntervalInMinutes?: number | null | undefined;
 }
 
 // A project MonitorStatus row a freshness fallback can resolve to.
@@ -27,32 +40,27 @@ export interface RollupStatusOption {
 }
 
 export class SiteStatusRollupUtil {
-  // A device is considered alive when SNMP data arrived within this window.
-  public static readonly DEFAULT_FRESHNESS_WINDOW_IN_MINUTES: number = 15;
-
   /*
    * Returns the winning MonitorStatus id for a set of devices, or null when
-   * no device contributes anything (empty subtree, or freshness fallbacks
-   * unavailable because the project has no operational/offline rows) - the
-   * caller treats null as "leave the site's status untouched".
+   * no device contributes anything (empty subtree, or fallbacks unavailable
+   * because the project has no operational/offline rows) - the caller
+   * treats null as "leave the site's status untouched".
    *
    * Per device: a stamped monitor status (with a known priority) wins;
-   * otherwise lastSeenAt within the freshness window maps to the project's
-   * isOperationalState row and anything staler (or never seen) maps to the
-   * isOfflineState row. Priority ties keep the first contributor (stable).
+   * otherwise the device's SNMP reachability maps Up to the project's
+   * isOperationalState row and Down to its isOfflineState row. A device
+   * that has never been polled contributes nothing at all - it is not
+   * evidence of an outage, and counting it as one used to pin a site red
+   * for as long as it took the first walk to land. Priority ties keep the
+   * first contributor (stable).
    */
   public static worstStatus(data: {
     deviceStates: Array<DeviceHealthState>;
     operationalStatus?: RollupStatusOption | null | undefined;
     offlineStatus?: RollupStatusOption | null | undefined;
     now?: Date | undefined;
-    freshnessWindowInMinutes?: number | undefined;
   }): string | null {
     const now: Date = data.now || new Date();
-    const windowInMinutes: number =
-      data.freshnessWindowInMinutes ??
-      SiteStatusRollupUtil.DEFAULT_FRESHNESS_WINDOW_IN_MINUTES;
-    const windowInMs: number = windowInMinutes * 60 * 1000;
 
     let winner: RollupStatusOption | null = null;
 
@@ -69,16 +77,25 @@ export class SiteStatusRollupUtil {
           priority: device.monitorStatusPriority,
         };
       } else {
-        const lastSeenAtInMs: number | null = device.lastSeenAt
-          ? new Date(device.lastSeenAt).getTime()
-          : null;
-        const isFresh: boolean =
-          lastSeenAtInMs !== null &&
-          now.getTime() - lastSeenAtInMs <= windowInMs;
+        const reachability: NetworkDeviceReachability =
+          DeviceReachabilityUtil.getStatus(
+            {
+              isReachable: device.isReachable,
+              lastPolledAt: device.lastPolledAt,
+              lastSeenAt: device.lastSeenAt,
+              pollingIntervalInMinutes: device.pollingIntervalInMinutes,
+            },
+            now,
+          );
+
+        if (reachability === NetworkDeviceReachability.Pending) {
+          continue;
+        }
 
-        candidate = isFresh
-          ? data.operationalStatus || null
-          : data.offlineStatus || null;
+        candidate =
+          reachability === NetworkDeviceReachability.Up
+            ? data.operationalStatus || null
+            : data.offlineStatus || null;
       }
 
       if (!candidate) {

package/Utils/Telemetry/CrossSignalScope.ts

@@ -1,4 +1,9 @@
 import Dictionary from "../../Types/Dictionary";
+import {
+  RESOURCE_ENTITY_FACET_KEYS,
+  ResourceEntityFacetSelections,
+  isResourceEntityFacetKey,
+} from "../../Types/Telemetry/ResourceEntityFacet";
 import OneUptimeDate from "../../Types/Date";
 import TimeRange from "../../Types/Time/TimeRange";
 import MetricExplorerUrl, {
@@ -61,6 +66,16 @@ const WHITESPACE: RegExp = /\s/;
 export interface TelemetryCrossSignalScope {
   /** Service ObjectID strings (Log/Span `primaryEntityId` values). */
   serviceIds?: Array<string> | undefined;
+  /**
+   * Non-Service resource selections keyed by facet — e.g.
+   * `{ kubernetesClusterId: ["<id>"] }`. Deliberately NOT merged into
+   * `serviceIds`: a host or cluster id is not a `primaryEntityId` value for
+   * telemetry that carries a `service.name`, so it has to reach the target
+   * explorer as its own facet and be resolved to the resource's entity key
+   * there. Both the logs and the traces `filters` grammar carry arbitrary
+   * facet keys, so these survive the trip intact.
+   */
+  resourceFacetSelections?: ResourceEntityFacetSelections | undefined;
   /** Exact-match telemetry attribute filters. Keys may contain dots. */
   attributes?: Dictionary<string> | undefined;
   traceIds?: Array<string> | undefined;
@@ -165,6 +180,36 @@ function sanitizeAttributeEntries(
   return entries;
 }
 
+/*
+ * Drop unknown facet keys and blank ids from a resource selection map. An
+ * unknown key would become a filter chip the target explorer cannot compile
+ * (it would land as an unknown column predicate), so it is reported as
+ * dropped by the callers instead of being emitted.
+ */
+function sanitizeResourceFacetSelections(
+  selections: ResourceEntityFacetSelections | undefined,
+): Array<[string, Array<string>]> {
+  if (!selections) {
+    return [];
+  }
+
+  const entries: Array<[string, Array<string>]> = [];
+
+  for (const facetKey of RESOURCE_ENTITY_FACET_KEYS) {
+    if (!isResourceEntityFacetKey(facetKey)) {
+      continue;
+    }
+
+    const values: Array<string> = sanitizeValues(selections[facetKey]);
+
+    if (values.length > 0) {
+      entries.push([facetKey, values]);
+    }
+  }
+
+  return entries;
+}
+
 function isValidDate(value: Date | undefined): value is Date {
   return value instanceof Date && !isNaN(value.getTime());
 }
@@ -250,6 +295,12 @@ export function toLogsExplorerQueryParams(
     tuples.push(["primaryEntityId", serviceIds]);
   }
 
+  for (const [facetKey, values] of sanitizeResourceFacetSelections(
+    scope.resourceFacetSelections,
+  )) {
+    tuples.push([facetKey, values]);
+  }
+
   const traceIds: Array<string> = sanitizeValues(scope.traceIds);
 
   if (traceIds.length > 0) {
@@ -372,6 +423,19 @@ export function toTracesExplorerQueryParams(
     filterTuples.push(["primaryEntityId", serviceId]);
   }
 
+  /*
+   * The traces `filters` grammar is one [key, value] pair per chip, so a
+   * multi-valued selection fans out into one chip per id — the explorer
+   * groups same-key chips back into a single facet selection.
+   */
+  for (const [facetKey, values] of sanitizeResourceFacetSelections(
+    scope.resourceFacetSelections,
+  )) {
+    for (const value of values) {
+      filterTuples.push([facetKey, value]);
+    }
+  }
+
   for (const [key, value] of sanitizeAttributeEntries(scope.attributes)) {
     const tokenValue: string | null = isTraceTokenSafeKey(key)
       ? buildTraceSearchTokenValue(value)
@@ -438,10 +502,11 @@ export function toTracesExplorerQueryParams(
  * Custom by the absolute params alone — see MetricExplorerUrl). The
  * optional `metricName` argument names the query.
  *
- * Dropped: serviceIds, traceIds, spanIds, severityTexts — the metric
- * explorer's URL grammar has no service / trace / span / severity
- * dimension (metrics carry a primaryEntityId column, but the explorer only
- * parses metricName + attributes out of `metricQueries`).
+ * Dropped: serviceIds, resourceFacetSelections, traceIds, spanIds,
+ * severityTexts — the metric explorer's URL grammar has no service /
+ * resource / trace / span / severity dimension (metrics carry a
+ * primaryEntityId column, but the explorer only parses metricName +
+ * attributes out of `metricQueries`).
  */
 export function toMetricsExplorerQueryParams(
   scope: TelemetryCrossSignalScope,
@@ -484,6 +549,12 @@ export function toMetricsExplorerQueryParams(
     dropped.push("serviceIds");
   }
 
+  for (const [facetKey] of sanitizeResourceFacetSelections(
+    scope.resourceFacetSelections,
+  )) {
+    dropped.push(facetKey);
+  }
+
   if (sanitizeValues(scope.traceIds).length > 0) {
     dropped.push("traceIds");
   }