@oneuptime/common 11.6.0 → 11.6.2

package/Utils/Dashboard/Components/DashboardSloComponent.ts

@@ -0,0 +1,114 @@
+import {
+  ComponentArgument,
+  ComponentArgumentSection,
+  ComponentInputType,
+  EntityFilterModelType,
+} from "../../../Types/Dashboard/DashboardComponents/ComponentArgument";
+import DashboardSloComponent, {
+  SloWidgetDisplayType,
+  SloWidgetMetric,
+} from "../../../Types/Dashboard/DashboardComponents/DashboardSloComponent";
+import DashboardComponentType from "../../../Types/Dashboard/DashboardComponentType";
+import { ObjectType } from "../../../Types/JSON";
+import ObjectID from "../../../Types/ObjectID";
+import DashboardBaseComponentUtil from "./DashboardBaseComponent";
+
+const DataSourceSection: ComponentArgumentSection = {
+  name: "Data Source",
+  description: "Pick the SLO and which of its numbers to show",
+  order: 1,
+};
+
+const DisplaySection: ComponentArgumentSection = {
+  name: "Display Options",
+  description: "Choose between a single value and a trend chart",
+  order: 2,
+};
+
+export default class DashboardSloComponentUtil extends DashboardBaseComponentUtil {
+  public static override getDefaultComponent(): DashboardSloComponent {
+    return {
+      _type: ObjectType.DashboardComponent,
+      componentType: DashboardComponentType.Slo,
+      /*
+       * Same footprint as the Gauge — the Tile default is a single big
+       * number, and a 3x3 tile still leaves room for the status pill and
+       * the target/budget subline once the widget is switched to Chart.
+       */
+      widthInDashboardUnits: 3,
+      heightInDashboardUnits: 3,
+      topInDashboardUnits: 0,
+      leftInDashboardUnits: 0,
+      componentId: ObjectID.generate(),
+      minHeightInDashboardUnits: 2,
+      minWidthInDashboardUnits: 2,
+      arguments: {
+        sloMetric: SloWidgetMetric.Sli,
+        displayType: SloWidgetDisplayType.Tile,
+      },
+    };
+  }
+
+  public static override getComponentConfigArguments(): Array<
+    ComponentArgument<DashboardSloComponent>
+  > {
+    const componentArguments: Array<ComponentArgument<DashboardSloComponent>> =
+      [];
+
+    componentArguments.push({
+      name: "Service Level Objective",
+      description: "The SLO this widget reports on",
+      required: true,
+      type: ComponentInputType.EntityDropdown,
+      id: "serviceLevelObjectiveId",
+      placeholder: "Select an SLO",
+      section: DataSourceSection,
+      entityFilterModelType: EntityFilterModelType.ServiceLevelObjective,
+    });
+
+    componentArguments.push({
+      name: "Metric",
+      description: "Which of the SLO's tracked numbers to show",
+      required: true,
+      type: ComponentInputType.Dropdown,
+      id: "sloMetric",
+      placeholder: "SLI",
+      section: DataSourceSection,
+      dropdownOptions: [
+        { label: "SLI (Service Level Indicator)", value: SloWidgetMetric.Sli },
+        {
+          label: "Error Budget Remaining",
+          value: SloWidgetMetric.ErrorBudgetRemaining,
+        },
+        { label: "Burn Rate", value: SloWidgetMetric.BurnRate },
+      ],
+    });
+
+    componentArguments.push({
+      name: "Display As",
+      description:
+        "Tile shows the current value. Chart shows the trend over the dashboard's time range.",
+      required: true,
+      type: ComponentInputType.Dropdown,
+      id: "displayType",
+      placeholder: "Tile",
+      section: DisplaySection,
+      dropdownOptions: [
+        { label: "Tile", value: SloWidgetDisplayType.Tile },
+        { label: "Chart", value: SloWidgetDisplayType.Chart },
+      ],
+    });
+
+    componentArguments.push({
+      name: "Title",
+      description:
+        "Header shown above the widget. Defaults to the SLO name and metric.",
+      required: false,
+      type: ComponentInputType.Text,
+      id: "widgetTitle",
+      section: DisplaySection,
+    });
+
+    return componentArguments;
+  }
+}

package/Utils/Dashboard/Components/Index.ts

@@ -31,6 +31,7 @@ import DashboardPodmanImageListComponentUtil from "./DashboardPodmanImageListCom
 import DashboardPodmanNetworkListComponentUtil from "./DashboardPodmanNetworkListComponent";
 import DashboardPodmanVolumeListComponentUtil from "./DashboardPodmanVolumeListComponent";
 import DashboardProxmoxGuestListComponentUtil from "./DashboardProxmoxGuestListComponent";
+import DashboardSloComponentUtil from "./DashboardSloComponent";
 import DashboardProxmoxNodeListComponentUtil from "./DashboardProxmoxNodeListComponent";
 import DashboardDockerSwarmNodeListComponentUtil from "./DashboardDockerSwarmNodeListComponent";
 import DashboardDockerSwarmServiceListComponentUtil from "./DashboardDockerSwarmServiceListComponent";
@@ -123,6 +124,12 @@ export default class DashboardComponentsUtil {
       >;
     }
 
+    if (dashboardComponentType === DashboardComponentType.Slo) {
+      return DashboardSloComponentUtil.getComponentConfigArguments() as Array<
+        ComponentArgument<DashboardBaseComponent>
+      >;
+    }
+
     if (dashboardComponentType === DashboardComponentType.KubernetesPodList) {
       return DashboardKubernetesPodListComponentUtil.getComponentConfigArguments() as Array<
         ComponentArgument<DashboardBaseComponent>

package/Utils/IpCanonicalUtil.ts

@@ -0,0 +1,134 @@
+import IP from "../Types/IP/IP";
+
+/*
+ * Canonical text form for IP literals, so two spellings of the same
+ * address compare equal. IPv4 already has a single canonical dotted-quad
+ * form; IPv6 does not — `2001:DB8::1`, `2001:db8:0:0:0:0:0:1` and
+ * `2001:db8::0001` are all the same address. Datagram sources (traps,
+ * syslog, flows) arrive in Node's normalized lowercase-compressed form,
+ * while device hostnames are whatever a human typed, so correlation must
+ * canonicalize both sides (RFC 5952: lowercase, no leading zeros, longest
+ * zero-run compressed, leftmost on ties, no compression of a single
+ * group).
+ *
+ * Non-IP input (DNS names, garbage) is returned unchanged.
+ */
+export default class IpCanonicalUtil {
+  public static canonicalize(value: string): string {
+    const trimmed: string = value.trim();
+
+    if (!IP.isIP(trimmed)) {
+      return trimmed;
+    }
+
+    const ip: IP = new IP(trimmed);
+
+    if (ip.isIPv4()) {
+      // Dotted-quad is already canonical.
+      return trimmed;
+    }
+
+    return IpCanonicalUtil.canonicalizeIpv6(trimmed);
+  }
+
+  // True when both values are IP literals of the same address.
+  public static areSameIpAddress(a: string, b: string): boolean {
+    const trimmedA: string = a.trim();
+    const trimmedB: string = b.trim();
+
+    if (!IP.isIP(trimmedA) || !IP.isIP(trimmedB)) {
+      return false;
+    }
+
+    return (
+      IpCanonicalUtil.canonicalize(trimmedA) ===
+      IpCanonicalUtil.canonicalize(trimmedB)
+    );
+  }
+
+  private static canonicalizeIpv6(value: string): string {
+    /*
+     * Expand to 8 groups. IPv4-mapped tails (::ffff:1.2.3.4) are folded
+     * into two hex groups so every address reduces to the same shape.
+     */
+    let input: string = value.toLowerCase();
+
+    const v4TailMatch: RegExpMatchArray | null = input.match(
+      /(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/,
+    );
+
+    if (v4TailMatch) {
+      const octets: Array<number> = v4TailMatch.slice(1, 5).map(Number);
+      const high: number = ((octets[0]! << 8) | octets[1]!) >>> 0;
+      const low: number = ((octets[2]! << 8) | octets[3]!) >>> 0;
+      input =
+        input.substring(0, input.length - v4TailMatch[0]!.length) +
+        `${high.toString(16)}:${low.toString(16)}`;
+    }
+
+    const doubleColonSplit: Array<string> = input.split("::");
+    const headGroups: Array<string> = doubleColonSplit[0]
+      ? doubleColonSplit[0].split(":").filter(Boolean)
+      : [];
+    const tailGroups: Array<string> =
+      doubleColonSplit.length > 1 && doubleColonSplit[1]
+        ? doubleColonSplit[1].split(":").filter(Boolean)
+        : [];
+
+    const missingGroups: number =
+      doubleColonSplit.length > 1
+        ? 8 - headGroups.length - tailGroups.length
+        : 0;
+
+    const groups: Array<number> = [
+      ...headGroups,
+      ...new Array(Math.max(0, missingGroups)).fill("0"),
+      ...tailGroups,
+    ].map((group: string) => {
+      return parseInt(group, 16) & 0xffff;
+    });
+
+    if (groups.length !== 8 || groups.some(Number.isNaN)) {
+      // Malformed despite passing IP.isIP — return as-is rather than lie.
+      return value.trim().toLowerCase();
+    }
+
+    /*
+     * RFC 5952 zero compression: longest run of 2+ zero groups, leftmost
+     * wins ties.
+     */
+    let bestStart: number = -1;
+    let bestLength: number = 0;
+    let runStart: number = -1;
+    let runLength: number = 0;
+
+    for (let i: number = 0; i < 8; i++) {
+      if (groups[i] === 0) {
+        if (runStart === -1) {
+          runStart = i;
+          runLength = 0;
+        }
+        runLength++;
+        if (runLength > bestLength) {
+          bestStart = runStart;
+          bestLength = runLength;
+        }
+      } else {
+        runStart = -1;
+        runLength = 0;
+      }
+    }
+
+    const hex: Array<string> = groups.map((group: number) => {
+      return group.toString(16);
+    });
+
+    if (bestLength >= 2) {
+      const head: string = hex.slice(0, bestStart).join(":");
+      const tail: string = hex.slice(bestStart + bestLength).join(":");
+      return `${head}::${tail}`;
+    }
+
+    return hex.join(":");
+  }
+}