@oneuptime/common 14.0.3 → 14.0.6

package/Tests/Utils/NetworkDiscovery/NetbiosNameUtil.test.ts

@@ -1,5 +1,6 @@
 import {
   MAX_NETBIOS_NAME_LENGTH,
+  isNetbiosQueryableIPv4Address,
   normalizeNetbiosName,
 } from "../../../Utils/NetworkDiscovery/NetbiosNameUtil";
 import { normalizeReverseDnsName } from "../../../Utils/NetworkDiscovery/ReverseDnsNameUtil";
@@ -347,3 +348,246 @@ describe("normalizeNetbiosName — invariants", () => {
     expect(acceptedCount).toBeGreaterThan(50);
   });
 });
+
+/*
+ * OneUptime issue #3916 — the Review dialog told an unnamed host on a scan
+ * with NetBIOS off that "NetBIOS lookup asks Windows hosts for their own
+ * name" whatever its address. The probe only ever queries private and CGNAT
+ * IPv4 (isNetbiosQueryAddressAllowed, Probe/Utils/Discovery/
+ * NetbiosNameResolver.ts), so on public space that advice led to a rescan
+ * whose only news was "not asked".
+ *
+ * This is the browser-safe copy of the probe's rule that the dialog now asks
+ * first. The expectations are written out by hand from RFC 1918 and RFC 6598,
+ * not computed, so a wrong range in the helper cannot agree with itself here.
+ * The probe's NetbiosEligibilityParity test then holds the helper to the
+ * probe's own answer on the same edges and a sweep.
+ */
+describe("isNetbiosQueryableIPv4Address — the addresses the probe would ask", () => {
+  it("accepts the first, last and an inside address of every range", () => {
+    for (const address of [
+      // 10.0.0.0/8
+      "10.0.0.0",
+      "10.0.0.1",
+      "10.16.42.51",
+      "10.255.255.255",
+      // 172.16.0.0/12
+      "172.16.0.0",
+      "172.20.1.2",
+      "172.31.255.255",
+      // 192.168.0.0/16
+      "192.168.0.0",
+      "192.168.1.1",
+      "192.168.255.255",
+      // 100.64.0.0/10, CGNAT
+      "100.64.0.0",
+      "100.100.100.100",
+      "100.127.255.255",
+    ]) {
+      expect({
+        address: address,
+        queryable: isNetbiosQueryableIPv4Address(address),
+      }).toEqual({ address: address, queryable: true });
+    }
+  });
+
+  it("refuses the address just outside each edge, and the special ranges", () => {
+    for (const address of [
+      "9.255.255.255",
+      "11.0.0.0",
+      "172.15.255.255",
+      "172.32.0.0",
+      "192.167.255.255",
+      "192.169.0.0",
+      "100.63.255.255",
+      "100.128.0.0",
+      // Public, documentation, loopback, link-local, broadcast, multicast.
+      "8.8.8.8",
+      "203.0.113.7",
+      "198.51.100.1",
+      "127.0.0.1",
+      "169.254.169.254",
+      "0.0.0.0",
+      "255.255.255.255",
+      "224.0.0.251",
+    ]) {
+      expect({
+        address: address,
+        queryable: isNetbiosQueryableIPv4Address(address),
+      }).toEqual({ address: address, queryable: false });
+    }
+  });
+
+  it("draws the 172.16/12 edge between 15 and 16, and between 31 and 32", () => {
+    expect(isNetbiosQueryableIPv4Address("172.15.0.1")).toBe(false);
+    expect(isNetbiosQueryableIPv4Address("172.16.0.1")).toBe(true);
+    expect(isNetbiosQueryableIPv4Address("172.31.0.1")).toBe(true);
+    expect(isNetbiosQueryableIPv4Address("172.32.0.1")).toBe(false);
+  });
+
+  it("draws the 100.64/10 edge between 63 and 64, and between 127 and 128", () => {
+    expect(isNetbiosQueryableIPv4Address("100.63.0.1")).toBe(false);
+    expect(isNetbiosQueryableIPv4Address("100.64.0.1")).toBe(true);
+    expect(isNetbiosQueryableIPv4Address("100.127.0.1")).toBe(true);
+    expect(isNetbiosQueryableIPv4Address("100.128.0.1")).toBe(false);
+  });
+
+  it("accepts exactly the second octets each first octet allows", () => {
+    /*
+     * Every second octet under the four first octets that have a range, and
+     * under the neighbours of each. The last two octets never matter, since
+     * no range is narrower than a /16, so each is tried at both ends.
+     */
+    const range: (start: number, count: number) => Array<number> = (
+      start: number,
+      count: number,
+    ): Array<number> => {
+      return Array.from({ length: count }, (_value: unknown, index: number) => {
+        return start + index;
+      });
+    };
+    const expected: Array<[number, Array<number>]> = [
+      [9, []],
+      [10, range(0, 256)],
+      [11, []],
+      [99, []],
+      [100, range(64, 64)],
+      [101, []],
+      [171, []],
+      [172, range(16, 16)],
+      [173, []],
+      [191, []],
+      [192, [168]],
+      [193, []],
+    ];
+
+    for (const [first, secondOctets] of expected) {
+      const accepted: Set<number> = new Set<number>();
+
+      for (let second: number = 0; second <= 255; second++) {
+        for (const tail of ["0.0", "0.1", "255.254", "255.255"]) {
+          if (isNetbiosQueryableIPv4Address(`${first}.${second}.${tail}`)) {
+            accepted.add(second);
+          }
+        }
+      }
+
+      expect({ first: first, accepted: Array.from(accepted) }).toEqual({
+        first: first,
+        accepted: secondOctets,
+      });
+    }
+  });
+
+  it("refuses leading zeros, which the probe's net.isIPv4 refuses", () => {
+    /*
+     * "010" is octal to some parsers and ten to others. The sweep never
+     * reports one, and the probe would refuse it, so the dialog must too.
+     */
+    for (const value of [
+      "010.0.0.1",
+      "10.00.0.1",
+      "10.0.00.1",
+      "10.0.0.01",
+      "10.0.0.00",
+      "0172.16.0.1",
+      "172.016.0.1",
+      "192.168.001.1",
+      "100.064.0.1",
+      "00.0.0.0",
+    ]) {
+      expect({
+        value: value,
+        queryable: isNetbiosQueryableIPv4Address(value),
+      }).toEqual({ value: value, queryable: false });
+    }
+  });
+
+  it("refuses surrounding or inner whitespace, rather than trimming it", () => {
+    for (const value of [
+      " 10.0.0.1",
+      "10.0.0.1 ",
+      "\t10.0.0.1",
+      "10.0.0.1\n",
+      "10.0.0.1\r\n",
+      "10. 0.0.1",
+      "10.0.0.1\u00a0",
+      "\u200b10.0.0.1",
+      "\ufeff10.0.0.1",
+      "10.0.0.1\u0000",
+    ]) {
+      expect({
+        value: value,
+        queryable: isNetbiosQueryableIPv4Address(value),
+      }).toEqual({ value: value, queryable: false });
+    }
+  });
+
+  it("refuses everything else that is not a strict dotted quad", () => {
+    for (const value of [
+      "",
+      ".",
+      "...",
+      "10.0.0",
+      "10.0.0.0.1",
+      "10.0.0.1.",
+      ".10.0.0.1",
+      "10..0.1",
+      "10.0.0.256",
+      "10.0.0.999",
+      "10.0.0.1000",
+      "10.0.0.-1",
+      "+10.0.0.1",
+      "0x0a.0.0.1",
+      "1e1.0.0.1",
+      "10.0.0.1/8",
+      "10.0.0.1:137",
+      "::ffff:10.0.0.1",
+      "::ffff:a00:1",
+      "fd00::1",
+      "fe80::1",
+      "2001:db8::5",
+      "::1",
+      "10.0.0.a",
+      "host.corp.example.com",
+      // Full-width and Arabic-Indic digits: digits, but not ASCII ones.
+      "\uff11\uff10.0.0.1",
+      "\u0661\u0660.0.0.1",
+    ]) {
+      expect({
+        value: value,
+        queryable: isNetbiosQueryableIPv4Address(value),
+      }).toEqual({ value: value, queryable: false });
+    }
+  });
+
+  it("refuses anything that is not a string, even one that stringifies to an address", () => {
+    /*
+     * The dialog reads the address out of jsonb. An array or an object with
+     * a toString would pass a check that coerced first; the probe checks the
+     * type, so this does too.
+     */
+    for (const value of [
+      undefined,
+      null,
+      167772161,
+      Number.NaN,
+      true,
+      ["10.0.0.1"],
+      {
+        toString: (): string => {
+          return "10.0.0.1";
+        },
+      },
+    ]) {
+      expect(isNetbiosQueryableIPv4Address(value)).toBe(false);
+    }
+  });
+
+  it("answers a very long input without throwing", () => {
+    expect(isNetbiosQueryableIPv4Address(`${"1".repeat(100000)}.0.0.1`)).toBe(
+      false,
+    );
+    expect(isNetbiosQueryableIPv4Address("10.".repeat(100000))).toBe(false);
+  });
+});

package/Tests/Utils/Rules/MonitorTypeRuleCriteria.test.ts

@@ -0,0 +1,181 @@
+import {
+  getMonitorTypeCriteriaValidationError,
+  isMonitorTypeCriteriaValue,
+} from "../../../Utils/Rules/MonitorTypeRuleCriteria";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import {
+  RuleCriteriaFilter,
+  RuleCriteriaOperator,
+  RuleCriteriaValue,
+} from "../../../Types/Rules/RuleCriteria";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The gate that decides whether a rule's `monitorType` criterion may be saved.
+ * DatabaseService runs it on every write and the SLO monitor-rule engine runs
+ * it again when it matches monitors, so a criterion this lets through has to
+ * be one the engine can actually evaluate: a monitor type is an enum choice,
+ * which means an exact match either way and nothing else. A text operator
+ * slipping past here is a rule that silently matches nothing.
+ */
+
+function buildFilter(
+  operator: RuleCriteriaOperator,
+  value: RuleCriteriaValue,
+): RuleCriteriaFilter {
+  return { field: "monitorType", operator: operator, value: value };
+}
+
+const OPERATOR_ERROR: string =
+  "Monitor type criteria only support Equals and Does not equal operators.";
+const VALUE_ERROR: string =
+  "Monitor type criteria require a valid monitor type.";
+
+describe("isMonitorTypeCriteriaValue", () => {
+  test("accepts every monitor type the product defines", () => {
+    const allTypes: Array<string> = Object.values(MonitorType);
+    expect(allTypes.length).toBeGreaterThan(0);
+    for (const monitorType of allTypes) {
+      expect(isMonitorTypeCriteriaValue(monitorType)).toBe(true);
+    }
+  });
+
+  test("rejects a string that is not a monitor type", () => {
+    expect(isMonitorTypeCriteriaValue("Website")).toBe(
+      Object.values(MonitorType).includes("Website" as MonitorType),
+    );
+    expect(isMonitorTypeCriteriaValue("NotAMonitorType")).toBe(false);
+    expect(isMonitorTypeCriteriaValue("")).toBe(false);
+  });
+
+  test("is case- and whitespace-sensitive, as an enum comparison must be", () => {
+    const [first] = Object.values(MonitorType) as Array<string>;
+    expect(isMonitorTypeCriteriaValue(first!)).toBe(true);
+    expect(isMonitorTypeCriteriaValue(first!.toLowerCase())).toBe(
+      first === first!.toLowerCase(),
+    );
+    expect(isMonitorTypeCriteriaValue(` ${first!}`)).toBe(false);
+    expect(isMonitorTypeCriteriaValue(`${first!} `)).toBe(false);
+  });
+
+  test("rejects every non-string value a criterion can carry", () => {
+    const nonStrings: Array<unknown> = [
+      undefined,
+      null,
+      0,
+      1,
+      true,
+      false,
+      [],
+      [Object.values(MonitorType)[0]],
+      {},
+      { value: Object.values(MonitorType)[0] },
+    ];
+    for (const value of nonStrings) {
+      expect(isMonitorTypeCriteriaValue(value)).toBe(false);
+    }
+  });
+
+  test("does not accept an inherited Object property as a monitor type", () => {
+    // The lookup is a Set, not a plain object, so "toString" is not a member.
+    expect(isMonitorTypeCriteriaValue("toString")).toBe(false);
+    expect(isMonitorTypeCriteriaValue("constructor")).toBe(false);
+    expect(isMonitorTypeCriteriaValue("__proto__")).toBe(false);
+  });
+});
+
+describe("getMonitorTypeCriteriaValidationError", () => {
+  const validType: MonitorType = Object.values(MonitorType)[0] as MonitorType;
+
+  test("passes Equals and NotEquals against a real monitor type", () => {
+    for (const operator of [
+      RuleCriteriaOperator.Equals,
+      RuleCriteriaOperator.NotEquals,
+    ]) {
+      expect(
+        getMonitorTypeCriteriaValidationError(buildFilter(operator, validType)),
+      ).toBeNull();
+    }
+  });
+
+  test("passes every monitor type under Equals", () => {
+    for (const monitorType of Object.values(MonitorType)) {
+      expect(
+        getMonitorTypeCriteriaValidationError(
+          buildFilter(RuleCriteriaOperator.Equals, monitorType),
+        ),
+      ).toBeNull();
+    }
+  });
+
+  test("rejects every operator other than Equals and NotEquals", () => {
+    const rejected: Array<RuleCriteriaOperator> = Object.values(
+      RuleCriteriaOperator,
+    ).filter((operator: RuleCriteriaOperator) => {
+      return (
+        operator !== RuleCriteriaOperator.Equals &&
+        operator !== RuleCriteriaOperator.NotEquals
+      );
+    });
+    expect(rejected.length).toBeGreaterThan(0);
+
+    for (const operator of rejected) {
+      expect(
+        getMonitorTypeCriteriaValidationError(buildFilter(operator, validType)),
+      ).toBe(OPERATOR_ERROR);
+    }
+  });
+
+  test("reports the operator first when both the operator and the value are wrong", () => {
+    expect(
+      getMonitorTypeCriteriaValidationError(
+        buildFilter(RuleCriteriaOperator.Contains, "NotAMonitorType"),
+      ),
+    ).toBe(OPERATOR_ERROR);
+  });
+
+  test("rejects a value that is not a monitor type under a supported operator", () => {
+    for (const operator of [
+      RuleCriteriaOperator.Equals,
+      RuleCriteriaOperator.NotEquals,
+    ]) {
+      expect(
+        getMonitorTypeCriteriaValidationError(
+          buildFilter(operator, "NotAMonitorType"),
+        ),
+      ).toBe(VALUE_ERROR);
+      expect(
+        getMonitorTypeCriteriaValidationError(buildFilter(operator, "")),
+      ).toBe(VALUE_ERROR);
+      /*
+       * An array is what the HasAnyOf-style operators carry; it is not a
+       * monitor type even when every member of it is one.
+       */
+      expect(
+        getMonitorTypeCriteriaValidationError(
+          buildFilter(operator, [validType]),
+        ),
+      ).toBe(VALUE_ERROR);
+      expect(
+        getMonitorTypeCriteriaValidationError(buildFilter(operator, true)),
+      ).toBe(VALUE_ERROR);
+      expect(
+        getMonitorTypeCriteriaValidationError(buildFilter(operator, 0)),
+      ).toBe(VALUE_ERROR);
+    }
+  });
+
+  test("ignores the filter's field: the caller decides which field this applies to", () => {
+    expect(
+      getMonitorTypeCriteriaValidationError({
+        field: "somethingElse",
+        operator: RuleCriteriaOperator.Equals,
+        value: validType,
+      }),
+    ).toBeNull();
+  });
+
+  test("the two errors are distinct, so a form can say which one it is", () => {
+    expect(OPERATOR_ERROR).not.toBe(VALUE_ERROR);
+  });
+});

package/Tests/Utils/ValueFormatter.test.ts

@@ -116,6 +116,30 @@ describe("ValueFormatter", () => {
         }),
       ).toBe("0.25");
     });
+
+    /*
+     * Redis' memory fragmentation ratio is resident over allocated memory:
+     * about 1.0 when healthy, 1.5 and up when fragmented. Read as a [0, 1]
+     * share it rendered 1.62 as "162.00%" on every chart and in every alert
+     * a user built on it.
+     */
+    test("a fragmentation ratio renders as the ratio it is, never x100", () => {
+      expect(
+        ValueFormatter.formatValue(1.62, "1", {
+          metricName: "redis.memory.fragmentation_ratio",
+        }),
+      ).toBe("1.62");
+      expect(
+        ValueFormatter.formatValue(1.62, "1", {
+          metricName: "redis_mem_fragmentation_ratio",
+        }),
+      ).toBe("1.62");
+      expect(
+        ValueFormatter.getCompactUnit("1", {
+          metricName: "redis.memory.fragmentation_ratio",
+        }),
+      ).toBe("");
+    });
   });
 
   describe("formatValue - annotation-only units", () => {
@@ -267,6 +291,32 @@ describe("ValueFormatter", () => {
         false,
       );
     });
+
+    test("a memory fragmentation ratio is not a fraction", () => {
+      // The OTel redis receiver, and redis_exporter's Prometheus name.
+      expect(
+        ValueFormatter.isFractionMetric("redis.memory.fragmentation_ratio"),
+      ).toBe(false);
+      expect(
+        ValueFormatter.isFractionMetric("redis_mem_fragmentation_ratio"),
+      ).toBe(false);
+      expect(
+        ValueFormatter.isFractionMetric(" Redis.Memory.Fragmentation_Ratio "),
+      ).toBe(false);
+    });
+
+    test("the fragmentation exclusion leaves every other ratio a fraction", () => {
+      for (const metricName of [
+        "db.client.connection.usage_ratio",
+        "redis.keyspace.hit_ratio",
+        "cache_hit_ratio",
+        "some_ratio",
+        // Anchored at the end: only the fragmentation ratio itself.
+        "redis.memory.fragmentation_ratio.utilization",
+      ]) {
+        expect(ValueFormatter.isFractionMetric(metricName)).toBe(true);
+      }
+    });
   });
 
   describe("kubeletstats cores gauges render as cores, never as a percent", () => {

package/Tests/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  /*
+   * The project every file in this directory belongs to: exactly
+   * ../tsconfig.tests.json, the program `npm run compile-tests` type-checks.
+   * Its "include" and "exclude" are inherited and resolve against
+   * packages/Common, where they are written.
+   *
+   * It exists because TypeScript picks a file's project by the nearest
+   * tsconfig.json - editors, and ESLint's typed linting (projectService in
+   * eslint.config.js). ../tsconfig.json excludes Tests, so without this file
+   * the lookup walked on up to the repository-root tsconfig.json, which has
+   * no "include": every Common test was linted, and opened in an editor,
+   * inside a program of the whole monorepo.
+   */
+  "extends": "../tsconfig.tests.json"
+}

package/Types/AI/AIResourceContext.ts

@@ -18,6 +18,7 @@ export enum AIResourceType {
   CloudResource = "CloudResource",
   IoTFleet = "IoTFleet",
   NetworkDevice = "NetworkDevice",
+  DatabaseServer = "DatabaseServer",
 }
 
 export enum AIResourceSubresourceKind {
@@ -81,6 +82,7 @@ const RESOURCE_FACET_KEYS: Record<AIResourceType, string> = {
   [AIResourceType.CloudResource]: "cloudResourceId",
   [AIResourceType.IoTFleet]: "iotFleetId",
   [AIResourceType.NetworkDevice]: "networkDeviceId",
+  [AIResourceType.DatabaseServer]: "databaseServerId",
 };
 
 /*
@@ -186,6 +188,11 @@ export const AI_RESOURCE_SUBRESOURCE_KINDS: Readonly<
   [AIResourceType.ServerlessFunction]: [AIResourceSubresourceKind.Instance],
   [AIResourceType.CloudResource]: [AIResourceSubresourceKind.Instance],
   [AIResourceType.NetworkDevice]: [AIResourceSubresourceKind.Interface],
+  /*
+   * A database's tabs (Endpoints, Metrics, Logs ...) are views of the one
+   * database, never a child with its own identity.
+   */
+  [AIResourceType.DatabaseServer]: [],
 };
 
 export function isAIResourceSubresourceKind(

package/Types/BaseDatabase/AggregationType.ts

@@ -15,6 +15,12 @@ enum AggregationType {
    * over the raw column, which is the right thing for scalar columns.
    */
   P50 = "P50",
+  /*
+   * The level Core Web Vitals are judged at: Google's good / poor
+   * thresholds for LCP, INP and CLS apply to the 75th percentile of page
+   * views, so a web-vital chart or monitor wants exactly this one.
+   */
+  P75 = "P75",
   P90 = "P90",
   P95 = "P95",
   P99 = "P99",
@@ -24,6 +30,7 @@ export default AggregationType;
 
 export const PercentileAggregationLevels: Record<string, number> = {
   [AggregationType.P50]: 0.5,
+  [AggregationType.P75]: 0.75,
   [AggregationType.P90]: 0.9,
   [AggregationType.P95]: 0.95,
   [AggregationType.P99]: 0.99,

package/Types/Dashboard/DashboardTemplates.ts

@@ -1742,6 +1742,18 @@ function createKubernetesDashboardConfig(): DashboardViewConfig {
    *   metrics and label them in cores ("2.3 cores"). The Kubernetes
    *   cluster overview page — which fetches `k8s.node.allocatable_cpu` —
    *   is where CPU is shown as a real "% of capacity".
+   *
+   * - "Cluster CPU (cores in use)" used to be a Value widget over
+   *   k8s.node.cpu.usage with `Sum` — the same trap as Pod Count. The
+   *   server sums every node's reading in each bucket and the Value widget
+   *   then sums the buckets, so a one-hour window of minute buckets and
+   *   30s kubelet scrapes read 540 for three nodes on 1.5 cores each,
+   *   instead of 4.5. A Value widget can't express "sum across nodes at one
+   *   instant", so the tile is now the busiest node's peak (`Max`), which
+   *   is honest at any window and complements the per-node average in
+   *   row 1. Cluster-wide CPU against capacity lives on the cluster
+   *   overview page. Dashboards already created from this template are
+   *   repaired by the RepairKubernetesDashboardClusterCpuTile migration.
    */
   const components: Array<DashboardBaseComponent> = [
     // Row 0: Title
@@ -1875,22 +1887,23 @@ function createKubernetesDashboardConfig(): DashboardViewConfig {
     }),
 
     /*
-     * Row 11-13: cluster CPU cores tile and the network throughput
-     * chart. This was a 0-100 CPU gauge, but the cores-valued
+     * Row 11-13: busiest-node CPU tile and the network throughput chart.
+     * This was a 0-100 CPU gauge, but the cores-valued
      * `k8s.node.cpu.utilization` pinned it to nonsense (e.g. 711%) and
      * the templated renderer can't divide by allocatable CPU to make a
-     * real percentage — so we show total cores in use instead. The old
-     * "Memory Utilization" gauge over raw bytes is gone — see
-     * top-of-function comment.
+     * real percentage. It then became a `Sum` of cores, which multiplied
+     * by the scrape count — see top-of-function comment. `Max` is the
+     * highest reading any single node reported in the window. The old
+     * "Memory Utilization" gauge over raw bytes is gone too.
      */
     createValueComponent({
-      title: "Cluster CPU (cores in use)",
+      title: "Busiest Node CPU (cores, peak)",
       top: 11,
       left: 0,
       width: 4,
       metricConfig: {
         metricName: "k8s.node.cpu.usage",
-        aggregationType: MetricsAggregationType.Sum,
+        aggregationType: MetricsAggregationType.Max,
       },
       trendDirection: DashboardValueTrendDirection.HigherIsWorse,
     }),
@@ -1939,7 +1952,8 @@ function createKubernetesDashboardConfig(): DashboardViewConfig {
       width: 6,
       height: 3,
       metricConfig: {
-        metricName: "k8s.deployment.available_replicas",
+        // The k8s_cluster receiver's name — there is no `_replicas` suffix.
+        metricName: "k8s.deployment.available",
         aggregationType: MetricsAggregationType.Min,
       },
     }),