@oneuptime/common 14.0.2 → 14.0.5

package/Utils/Rum/SessionTraceState.ts

@@ -0,0 +1,212 @@
+/*
+ * The replay session id, carried on W3C trace context.
+ *
+ * The browser recorder adds one `tracestate` list member to the requests a
+ * page makes to its own origin:
+ *
+ *   tracestate: oneuptime=sid:<32 hex session id>[;p:<16 hex parent id>]
+ *
+ * tracestate is the one channel a stock OpenTelemetry backend carries
+ * without being told to. Every SDK's W3C propagator extracts it onto the
+ * remote parent, every child span inherits it, every OTLP exporter sends
+ * it as the span's `traceState`, and every outgoing call re-injects it. So
+ * span ingest can stamp Span.sessionId for every service a browser request
+ * touched, with no code in the customer's backend. (OTLP log records carry
+ * no trace state; logs are joined to a session by trace id instead.)
+ *
+ * `p` is present only when the recorder MINTED the traceparent. Its parent
+ * id then names a browser span that is never exported, so the backend's
+ * entry span would otherwise arrive pointing at a parent that does not
+ * exist: never a root span, flagged as missing its parent. Ingest treats a
+ * span whose parent is exactly `p` as the root it really is.
+ *
+ * Both halves live here so the recorder that writes the member and the
+ * ingest that reads it cannot drift. Standalone functions rather than
+ * class statics, because the recorder bundle tree-shakes unused exports
+ * but not unused statics - the recorder imports only the builder.
+ *
+ * Dependency-free: bundled into the browser recorder as well as imported
+ * by the server.
+ */
+
+/* The list-member key. A valid W3C tracestate simple key. */
+export const SESSION_TRACE_STATE_KEY: string = "oneuptime";
+
+/*
+ * Hostile-input bounds for the parser. W3C caps a well-formed header at 32
+ * members, and the OpenTelemetry JS SDK at 512 characters, but other SDKs
+ * only cap member count and member length, so a legitimate value carrying
+ * other vendors' members can be longer than 512. Past these a value is not
+ * one the recorder wrote, so no session is read out of it - but our
+ * members are still stripped from it.
+ */
+const MAX_TRACE_STATE_LENGTH: number = 8192;
+const MAX_TRACE_STATE_MEMBERS: number = 64;
+
+const SESSION_ID_PATTERN: RegExp = /^[0-9a-f]{32}$/;
+const PARENT_SPAN_ID_PATTERN: RegExp = /^[0-9a-f]{16}$/;
+const ALL_ZERO_PATTERN: RegExp = /^0+$/;
+
+export interface SessionTraceState {
+  /* 32 lowercase hex characters. */
+  sessionId: string;
+
+  /*
+   * 16 lowercase hex characters: the parent id of a traceparent the
+   * recorder minted, which no exported span carries. null when the
+   * traceparent came from the page or its own instrumentation.
+   */
+  syntheticParentSpanId: string | null;
+}
+
+export interface ParsedSessionTraceState {
+  /* The session member, or null when there is none or it is malformed. */
+  sessionTraceState: SessionTraceState | null;
+
+  /*
+   * The trace state with every `oneuptime` member removed, so the session
+   * id is stored in exactly one column - the one erasure deletes by -
+   * rather than also in the raw trace state. Other vendors' members are
+   * kept verbatim (trimmed of optional whitespace), in order.
+   */
+  remainingTraceState: string;
+}
+
+/*
+ * The tracestate list member for a session. Callers pass recorder-minted
+ * values (a 32-hex session id, a 16-hex parent id); nothing here needs
+ * escaping, because hex and the ':' / ';' separators are all legal in a
+ * tracestate value.
+ */
+export function buildSessionTraceStateMember(
+  sessionId: string,
+  syntheticParentSpanId?: string | null,
+): string {
+  return (
+    SESSION_TRACE_STATE_KEY +
+    "=sid:" +
+    sessionId +
+    (syntheticParentSpanId ? ";p:" + syntheticParentSpanId : "")
+  );
+}
+
+/*
+ * Read the session member out of a span's trace state.
+ *
+ * Accepts anything, because the value comes from an OTLP body a customer
+ * (or anyone holding an ingestion key) controls: a non-string, an
+ * oversized string or a malformed member yields no session and never
+ * throws. The first `oneuptime` member wins, as in the W3C rule that a
+ * vendor's own member is the left-most one; fields inside it are
+ * `name:value` pairs separated by ';', in any order, and unknown fields are
+ * ignored so the format can grow.
+ */
+export function parseSessionTraceState(
+  traceState: unknown,
+): ParsedSessionTraceState {
+  if (typeof traceState !== "string") {
+    return { sessionTraceState: null, remainingTraceState: "" };
+  }
+
+  /*
+   * Fast path, and the path almost every span takes: no member of ours,
+   * nothing to parse and nothing to strip.
+   */
+  if (traceState.indexOf(SESSION_TRACE_STATE_KEY) === -1) {
+    return { sessionTraceState: null, remainingTraceState: traceState };
+  }
+
+  const members: Array<string> = traceState.split(",");
+
+  /*
+   * Past the bounds nothing is READ as a session - a value this far out of
+   * spec is not one the recorder wrote - but our members are still
+   * stripped, so an id cannot survive in the raw trace state just because
+   * the value around it was oversized.
+   */
+  const isWithinBounds: boolean =
+    traceState.length <= MAX_TRACE_STATE_LENGTH &&
+    members.length <= MAX_TRACE_STATE_MEMBERS;
+
+  let sessionTraceState: SessionTraceState | null = null;
+  let sawSessionMember: boolean = false;
+  const remaining: Array<string> = [];
+
+  for (const rawMember of members) {
+    const member: string = rawMember.trim();
+
+    if (member === "") {
+      continue;
+    }
+
+    const equalsIndex: number = member.indexOf("=");
+    const key: string =
+      equalsIndex === -1 ? member : member.slice(0, equalsIndex).trim();
+
+    if (key !== SESSION_TRACE_STATE_KEY) {
+      remaining.push(member);
+      continue;
+    }
+
+    /*
+     * Every member under our key is stripped, parsed or not: a malformed
+     * one can still hold an id, and the point of stripping is that no id
+     * survives outside the sessionId column.
+     */
+    if (isWithinBounds && !sawSessionMember && equalsIndex !== -1) {
+      sessionTraceState = readSessionMemberValue(member.slice(equalsIndex + 1));
+    }
+
+    sawSessionMember = true;
+  }
+
+  return {
+    sessionTraceState: sessionTraceState,
+    remainingTraceState: remaining.join(","),
+  };
+}
+
+function readSessionMemberValue(value: string): SessionTraceState | null {
+  let sessionId: string | null = null;
+  let syntheticParentSpanId: string | null = null;
+
+  for (const rawField of value.split(";")) {
+    const field: string = rawField.trim();
+    const colonIndex: number = field.indexOf(":");
+
+    if (colonIndex === -1) {
+      continue;
+    }
+
+    const name: string = field.slice(0, colonIndex);
+    const fieldValue: string = field.slice(colonIndex + 1).toLowerCase();
+
+    if (name === "sid" && sessionId === null) {
+      if (!SESSION_ID_PATTERN.test(fieldValue)) {
+        return null;
+      }
+
+      sessionId = fieldValue;
+    } else if (name === "p" && syntheticParentSpanId === null) {
+      /*
+       * A malformed parent id costs only the root-span repair, never the
+       * session: the session id is what the member is for.
+       */
+      if (
+        PARENT_SPAN_ID_PATTERN.test(fieldValue) &&
+        !ALL_ZERO_PATTERN.test(fieldValue)
+      ) {
+        syntheticParentSpanId = fieldValue;
+      }
+    }
+  }
+
+  if (sessionId === null || ALL_ZERO_PATTERN.test(sessionId)) {
+    return null;
+  }
+
+  return {
+    sessionId: sessionId,
+    syntheticParentSpanId: syntheticParentSpanId,
+  };
+}

package/Utils/Telemetry/DatabaseServerEntityKeys.ts

@@ -0,0 +1,275 @@
+import { keyForDatabaseEndpoint, keyForDatabaseServerRow } from "./EntityKey";
+import {
+  DatabaseEndpoint,
+  parseDatabaseEndpointString,
+} from "../../Types/DatabaseServer/DatabaseEndpoint";
+
+/*
+ * The entity-key set of a DatabaseServer row — the ONE definition of "this
+ * database's telemetry" shared by the dashboard pages (Logs / Traces /
+ * Metrics / Overview), the explorer facet and anything else that scopes by
+ * database. A row's keys are:
+ *
+ *   - its ROW key (keyForDatabaseServerRow): ingest stamps it on every batch
+ *     that resolved to this row — by its `oneuptime.database.server.id`
+ *     link or by an endpoint it owns — so linked telemetry is this
+ *     database's whatever address (or none) the batch reported;
+ *   - one `database.server` key per stored endpoint (DatabaseServerEndpoint
+ *     rows): exactly the endpoints Settings shows, no derived twins, so what
+ *     the page queries is what the user can see and edit;
+ *   - its member keys: the Kubernetes pods / Deployments and Docker / Podman
+ *     containers it runs as, remembered with a last-seen time so a pod that
+ *     restarted (new name, new container id) keeps its crash logs visible.
+ *
+ * Kept out of EntityKey.ts on purpose: that module must stay a leaf, and
+ * this one needs the endpoint parser.
+ */
+
+/** entityKey → ISO timestamp it was last seen as a member. */
+export type DatabaseServerMemberKeys = Record<string, string>;
+
+export const DEFAULT_MEMBER_KEY_MAX_AGE_DAYS: number = 30;
+export const DEFAULT_MEMBER_KEY_MAX_COUNT: number = 200;
+export const MAX_DATABASE_SERVER_ENTITY_KEYS: number = 200;
+
+const ENTITY_KEY_REGEX: RegExp = /^[0-9a-f]{16}$/;
+const DAY_IN_MS: number = 24 * 60 * 60 * 1000;
+
+function normalizeEntityKey(value: unknown): string | null {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const key: string = value.trim().toLowerCase();
+  return ENTITY_KEY_REGEX.test(key) ? key : null;
+}
+
+function toTimestamp(value: unknown): number | null {
+  if (typeof value !== "string" && !(value instanceof Date)) {
+    return null;
+  }
+  const time: number =
+    value instanceof Date ? value.getTime() : Date.parse(value);
+  return Number.isFinite(time) ? time : null;
+}
+
+/*
+ * Read a stored member-key value leniently: the canonical `{ key: iso }`
+ * map, or an array of `{ key, lastSeenAt }` entries (plus, when
+ * `acceptBareKeys`, bare key strings, treated as oldest). Anything malformed
+ * is skipped, never thrown on — the column is JSON written by a worker.
+ */
+function readMemberKeys(
+  value: unknown,
+  acceptBareKeys: boolean = false,
+): Map<string, number> {
+  const entries: Map<string, number> = new Map<string, number>();
+
+  const add: (rawKey: unknown, rawTime: unknown) => void = (
+    rawKey: unknown,
+    rawTime: unknown,
+  ): void => {
+    const key: string | null = normalizeEntityKey(rawKey);
+    const time: number | null = toTimestamp(rawTime);
+    if (key === null || time === null) {
+      return;
+    }
+    const existing: number | undefined = entries.get(key);
+    if (existing === undefined || time > existing) {
+      entries.set(key, time);
+    }
+  };
+
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      if (acceptBareKeys && typeof item === "string") {
+        add(item, new Date(0));
+      } else if (item && typeof item === "object") {
+        add(
+          (item as { key?: unknown }).key,
+          (item as { lastSeenAt?: unknown }).lastSeenAt,
+        );
+      }
+    }
+    return entries;
+  }
+
+  if (value && typeof value === "object") {
+    for (const rawKey of Object.keys(value as Record<string, unknown>)) {
+      add(rawKey, (value as Record<string, unknown>)[rawKey]);
+    }
+  }
+
+  return entries;
+}
+
+// Most recent first; ties broken by key so the order is stable.
+function sortByRecency(
+  entries: Map<string, number>,
+): Array<{ key: string; time: number }> {
+  return Array.from(entries.entries())
+    .map(([key, time]: [string, number]): { key: string; time: number } => {
+      return { key, time };
+    })
+    .sort(
+      (
+        a: { key: string; time: number },
+        b: { key: string; time: number },
+      ): number => {
+        if (b.time !== a.time) {
+          return b.time - a.time;
+        }
+        if (a.key < b.key) {
+          return -1;
+        }
+        return a.key > b.key ? 1 : 0;
+      },
+    );
+}
+
+/**
+ * Merge the member keys seen this run into the stored set: seen keys are
+ * stamped `now`, older ones are kept until they have not been seen for
+ * `maxAgeDays` (default 30 — a restarted pod's logs stay on the page), and
+ * the set is capped at `max` (default 200) by recency. Timestamps in the
+ * future are clamped to `now`. Never throws.
+ */
+export function mergeDatabaseServerMemberKeys(
+  existing: unknown,
+  seenNow: Array<string>,
+  now: Date,
+  opts?: { maxAgeDays?: number | undefined; max?: number | undefined },
+): DatabaseServerMemberKeys {
+  const nowTime: number =
+    now instanceof Date && Number.isFinite(now.getTime())
+      ? now.getTime()
+      : Date.now();
+
+  const maxAgeDays: number =
+    typeof opts?.maxAgeDays === "number" && opts.maxAgeDays > 0
+      ? opts.maxAgeDays
+      : DEFAULT_MEMBER_KEY_MAX_AGE_DAYS;
+  const max: number =
+    typeof opts?.max === "number" && opts.max >= 1
+      ? Math.floor(opts.max)
+      : DEFAULT_MEMBER_KEY_MAX_COUNT;
+
+  const entries: Map<string, number> = readMemberKeys(existing);
+
+  for (const [key, time] of entries) {
+    if (time > nowTime) {
+      entries.set(key, nowTime);
+    }
+  }
+
+  for (const raw of Array.isArray(seenNow) ? seenNow : []) {
+    const key: string | null = normalizeEntityKey(raw);
+    if (key !== null) {
+      entries.set(key, nowTime);
+    }
+  }
+
+  const cutoff: number = nowTime - maxAgeDays * DAY_IN_MS;
+
+  const merged: DatabaseServerMemberKeys = {};
+  let count: number = 0;
+  for (const entry of sortByRecency(entries)) {
+    if (entry.time < cutoff) {
+      continue;
+    }
+    if (count >= max) {
+      break;
+    }
+    merged[entry.key] = new Date(entry.time).toISOString();
+    count++;
+  }
+
+  return merged;
+}
+
+/*
+ * A row id as text: a string or anything with a string form (an ObjectID),
+ * trimmed; "" when there is none.
+ */
+function databaseServerIdText(value: unknown): string {
+  if (typeof value === "string") {
+    return value.trim();
+  }
+  if (value && typeof value === "object") {
+    const text: unknown = (value as { toString: () => unknown }).toString();
+    return typeof text === "string" && text !== "[object Object]"
+      ? text.trim()
+      : "";
+  }
+  return "";
+}
+
+/**
+ * Every entity key that belongs to a DatabaseServer: its row key (when the
+ * row's id is given), then the `database.server` key of each parseable
+ * stored endpoint (engine default port applied, as ingest does), then its
+ * member keys (valid 16-hex keys only, most recent first). Deduped, stable,
+ * capped at 200 with the row key first and endpoint keys next, so a large
+ * member set never evicts either.
+ *
+ * An empty result means "nothing to query" — callers must NEVER turn it into
+ * an empty `Includes` (that drops the predicate and scopes to the whole
+ * project).
+ */
+export function getDatabaseServerSignalEntityKeys(input: {
+  projectId: string;
+  /*
+   * The row's id. Its row key is what ingest stamps on telemetry linked to
+   * the row by `oneuptime.database.server.id`; leave it out only for a key
+   * set that must not include linked telemetry (the member-only runtime
+   * scope).
+   */
+  databaseServerId?: string | { toString: () => string } | null | undefined;
+  endpoints:
+    | Array<string | { endpoint?: string | null | undefined }>
+    | null
+    | undefined;
+  dbSystem?: string | null | undefined;
+  memberEntityKeys: unknown;
+}): Array<string> {
+  const projectId: string =
+    input && typeof input.projectId === "string" ? input.projectId.trim() : "";
+  if (!projectId) {
+    return [];
+  }
+
+  const keys: Array<string> = [];
+  const seen: Set<string> = new Set<string>();
+  const push: (key: string) => void = (key: string): void => {
+    if (keys.length < MAX_DATABASE_SERVER_ENTITY_KEYS && !seen.has(key)) {
+      seen.add(key);
+      keys.push(key);
+    }
+  };
+
+  const databaseServerId: string = databaseServerIdText(input.databaseServerId);
+  if (databaseServerId) {
+    push(keyForDatabaseServerRow(projectId, databaseServerId));
+  }
+
+  for (const item of Array.isArray(input.endpoints) ? input.endpoints : []) {
+    const value: unknown =
+      item && typeof item === "object"
+        ? (item as { endpoint?: unknown }).endpoint
+        : item;
+    const endpoint: DatabaseEndpoint | null = parseDatabaseEndpointString(
+      value,
+      { system: input.dbSystem || "" },
+    );
+    if (endpoint) {
+      push(keyForDatabaseEndpoint(projectId, endpoint));
+    }
+  }
+
+  for (const entry of sortByRecency(
+    readMemberKeys(input.memberEntityKeys, true),
+  )) {
+    push(entry.key);
+  }
+
+  return keys;
+}

package/Utils/Telemetry/EntityKey.ts

@@ -222,6 +222,182 @@ export function keyForVMwareVCenter(
   });
 }
 
+/*
+ * Mirrors the resolvers' `str` / `addIfPresent`: a blank or whitespace-only
+ * value is not identity-bearing, so it must be left out of the identity set
+ * rather than hashed as "".
+ */
+function isIdentityBearing(value: string | null | undefined): value is string {
+  return (
+    value !== undefined && value !== null && String(value).trim().length > 0
+  );
+}
+
+/**
+ * `k8s.cluster.name` + `k8s.namespace.name` + `k8s.pod.name` is the pod
+ * identity (mirrors the k8s.pod resolver in `InventoryItem.extractEntities`,
+ * which is name-preferring and folds in the cluster and namespace only when
+ * the resource carries them). Pass the cluster's `clusterIdentifier`, the
+ * pod's namespace and its name.
+ */
+export function keyForKubernetesPod(
+  projectId: string,
+  data: {
+    clusterName?: string | null | undefined;
+    namespace?: string | null | undefined;
+    podName: string;
+  },
+): string {
+  const identifyingAttributes: Dictionary<string> = {};
+
+  if (isIdentityBearing(data.clusterName)) {
+    identifyingAttributes["k8s.cluster.name"] = data.clusterName;
+  }
+  if (isIdentityBearing(data.namespace)) {
+    identifyingAttributes["k8s.namespace.name"] = data.namespace;
+  }
+  identifyingAttributes["k8s.pod.name"] = data.podName;
+
+  return computeEntityKey({
+    projectId,
+    entityType: EntityType.KubernetesPod,
+    identifyingAttributes,
+  });
+}
+
+/**
+ * `k8s.cluster.name` + `k8s.namespace.name` + `k8s.deployment.name` is the
+ * deployment identity (mirrors the k8s.deployment resolver). Pass the
+ * cluster's `clusterIdentifier`, the namespace and the Deployment name.
+ */
+export function keyForKubernetesDeployment(
+  projectId: string,
+  data: {
+    clusterName?: string | null | undefined;
+    namespace?: string | null | undefined;
+    deploymentName: string;
+  },
+): string {
+  const identifyingAttributes: Dictionary<string> = {};
+
+  if (isIdentityBearing(data.clusterName)) {
+    identifyingAttributes["k8s.cluster.name"] = data.clusterName;
+  }
+  if (isIdentityBearing(data.namespace)) {
+    identifyingAttributes["k8s.namespace.name"] = data.namespace;
+  }
+  identifyingAttributes["k8s.deployment.name"] = data.deploymentName;
+
+  return computeEntityKey({
+    projectId,
+    entityType: EntityType.KubernetesDeployment,
+    identifyingAttributes,
+  });
+}
+
+/**
+ * `container.id` is the container identity (mirrors the container resolver
+ * — id-only). Pass the raw `container.id` attribute value (the full id, as
+ * docker_stats / the container log path report it).
+ *
+ * Lives in this isomorphic module (it used to be server-only, in the
+ * server's entity resolver, which still re-exports it) because the Databases
+ * product computes a Docker/Podman database's member keys in the browser as
+ * well as in the worker.
+ */
+export function keyForContainer(
+  projectId: string,
+  containerId: string,
+): string {
+  return computeEntityKey({
+    projectId,
+    entityType: EntityType.Container,
+    identifyingAttributes: { "container.id": containerId },
+  });
+}
+
+/**
+ * Key for a database SERVER endpoint — the `database.server` membership key
+ * ingest appends to DB client spans, `db.client.*` datapoints and DB
+ * receiver batches that did not resolve to a row by its id, and the
+ * Databases product queries by (next to the row's own key,
+ * `keyForDatabaseServerRow`).
+ *
+ * Pass an endpoint already canonicalized by
+ * `Types/DatabaseServer/DatabaseEndpoint` (canonical host, default port
+ * applied, cluster qualifier only where it applies). This module takes
+ * primitives rather than importing that one so it stays a leaf.
+ *
+ * Deliberately ENGINE-AGNOSTIC: `db.system.name` is not part of the identity.
+ * `host:port` already names one listener, and wire-compatible engines report
+ * a different system than the server's own (CockroachDB / YugabyteDB clients
+ * say `postgresql`, OpenSearch clients say `elasticsearch`), so including it
+ * would split one server across keys.
+ */
+export function keyForDatabaseEndpoint(
+  projectId: string,
+  endpoint: {
+    host: string;
+    port: number | null;
+    kubernetesClusterName?: string | null | undefined;
+  },
+): string {
+  const identifyingAttributes: Dictionary<string> = {
+    "server.address": endpoint.host,
+  };
+
+  if (endpoint.port !== null && endpoint.port !== undefined) {
+    identifyingAttributes["server.port"] = String(endpoint.port);
+  }
+  if (isIdentityBearing(endpoint.kubernetesClusterName)) {
+    identifyingAttributes["k8s.cluster.name"] = endpoint.kubernetesClusterName;
+  }
+
+  return computeEntityKey({
+    projectId,
+    entityType: EntityType.DatabaseServer,
+    identifyingAttributes,
+  });
+}
+
+/**
+ * Identity attribute of a DatabaseServer ROW key — the attribute ingest
+ * stamps on the same telemetry (see `TelemetryUtil.getAttributesForDatabaseServerIdAndName`).
+ */
+export const DATABASE_SERVER_ROW_IDENTITY_ATTRIBUTE: string =
+  "oneuptime.database.server.id";
+
+/**
+ * Key for one DatabaseServer ROW, the `database.server` membership key that
+ * ties telemetry to the database it was attributed to rather than to an
+ * address. Ingest appends it to every row of a batch that resolved to a
+ * DatabaseServer — as the primary entity, or only through the
+ * `oneuptime.database.server.id` stamp — and the database's own key set
+ * (`getDatabaseServerSignalEntityKeys`) always contains it.
+ *
+ * Endpoint keys alone cannot carry that: a Database Agent linked by
+ * `DATABASE_SERVER_ID` may report an address the row does not own (a
+ * cluster-local name without its cluster, a private IP, an address another
+ * database owns) or no address at all (memcached, elasticsearch), and its
+ * data would then land on no database's page — or on the wrong one.
+ *
+ * Distinct from `keyForDatabaseEndpoint` (same entity type, different
+ * identifying attribute), so a row key never equals an endpoint key. Pass
+ * the row's id; it is canonicalized (lowercased) like every identity value.
+ */
+export function keyForDatabaseServerRow(
+  projectId: string,
+  databaseServerId: string,
+): string {
+  return computeEntityKey({
+    projectId,
+    entityType: EntityType.DatabaseServer,
+    identifyingAttributes: {
+      [DATABASE_SERVER_ROW_IDENTITY_ATTRIBUTE]: databaseServerId,
+    },
+  });
+}
+
 /*
  * ---- Rows without telemetry ----------------------------------------------
  *

package/Utils/ValueFormatter.ts

@@ -731,6 +731,22 @@ export default class ValueFormatter {
       return false;
     }
 
+    /*
+     * A memory fragmentation ratio (the redis receiver's
+     * `redis.memory.fragmentation_ratio`, redis_exporter's
+     * `redis_mem_fragmentation_ratio`) is resident over allocated memory —
+     * about 1.0 when healthy, 1.5 and up when fragmented, below 1 when the
+     * host swaps — not a [0, 1] share, so it is shown as the ratio (1.62,
+     * never "162.00%"). Anchored at the end like the suffix rule below, so
+     * every other `_ratio` still renders as a percent. Also what a Value or
+     * Gauge widget on it compares its thresholds against: the ratio's own
+     * scale.
+     */
+    const memoryFragmentationRatio: RegExp = /fragmentation_ratio$/i;
+    if (memoryFragmentationRatio.test(metricName.trim())) {
+      return false;
+    }
+
     const fractionMetricSuffixRegex: RegExp =
       /[._](utilization|ratio|fraction|percent|percentage)$/i;
     return fractionMetricSuffixRegex.test(metricName);