@oneuptime/common 10.4.11 → 10.4.12

package/Types/Dashboard/DashboardTemplates.ts

@@ -5,13 +5,13 @@ import DashboardComponentType from "./DashboardComponentType";
 import DashboardChartType from "./Chart/ChartType";
 import ObjectID from "../ObjectID";
 import DashboardBaseComponent from "./DashboardComponents/DashboardBaseComponent";
+import DashboardVariable, { DashboardVariableType } from "./DashboardVariable";
 import IconProp from "../Icon/IconProp";
 import MetricsAggregationType from "../Metrics/MetricsAggregationType";
 import IncidentMetricType from "../Incident/IncidentMetricType";
 import MonitorMetricType from "../Monitor/MonitorMetricType";
 import MetricDashboardMetricType from "../Metrics/MetricDashboardMetricType";
 import { DashboardValueTrendDirection } from "./DashboardComponents/DashboardValueComponent";
-import { HostMetricKind } from "./DashboardComponents/DashboardHostMetricChartComponent";
 
 /*
  * Trace / Exception / Profiles entries are intentionally not in this
@@ -88,6 +88,19 @@ interface MetricConfig {
   aggregationType: MetricsAggregationType;
   legend?: string;
   legendUnit?: string;
+  /*
+   * OpenTelemetry attribute keys to fan the query out across (e.g.
+   * ["host.name"] for one series per host). When set, the chart renders
+   * one series per unique value combination.
+   */
+  groupByAttributeKeys?: Array<string>;
+  /*
+   * Plot the per-second rate of change instead of the raw cumulative
+   * counter. Required for OTel cumulative counters such as
+   * `system.disk.io` and `system.network.io` so the chart shows I/O rate
+   * rather than bytes-since-boot.
+   */
+  transformAsRate?: boolean;
 }
 
 function buildMetricQueryConfig(config: MetricConfig): Record<string, unknown> {
@@ -104,8 +117,10 @@ function buildMetricQueryConfig(config: MetricConfig): Record<string, unknown> {
         metricName: config.metricName,
         aggegationType: config.aggregationType,
       },
-      groupBy: undefined,
+      groupBy: config.groupByAttributeKeys ? { attributes: true } : undefined,
+      groupByAttributeKeys: config.groupByAttributeKeys,
     },
+    transformAsRate: config.transformAsRate,
   };
 }
 
@@ -383,6 +398,31 @@ function createKubernetesNodeListComponent(data: {
   };
 }
 
+/*
+ * Template variables are pre-built TelemetryAttribute variables that
+ * ship with the template — the toolbar renders a "Cluster" /
+ * "Namespace" / "Host" picker without the user having to open the
+ * Variables modal. Resource attributes from the OTel collector are
+ * stored in ClickHouse under the `resource.` prefix (see the comment
+ * in MonitorAlert.ts), so the binding keys here mirror what the
+ * Kubernetes / Host detail pages already filter on.
+ */
+function createTelemetryAttributeVariable(data: {
+  name: string;
+  label: string;
+  attributeKey: string;
+  isMultiSelect?: boolean;
+}): DashboardVariable {
+  return {
+    id: ObjectID.generate().toString(),
+    name: data.name,
+    label: data.label,
+    type: DashboardVariableType.TelemetryAttribute,
+    attributeKey: data.attributeKey,
+    isMultiSelect: data.isMultiSelect ?? false,
+  };
+}
+
 function createHostListComponent(data: {
   title: string;
   top: number;
@@ -412,33 +452,6 @@ function createHostListComponent(data: {
   };
 }
 
-function createHostMetricChartComponent(data: {
-  title: string;
-  description?: string;
-  metricKind: HostMetricKind;
-  top: number;
-  left: number;
-  width: number;
-  height: number;
-}): DashboardBaseComponent {
-  return {
-    _type: ObjectType.DashboardComponent,
-    componentType: DashboardComponentType.HostMetricChart,
-    componentId: ObjectID.generate(),
-    topInDashboardUnits: data.top,
-    leftInDashboardUnits: data.left,
-    widthInDashboardUnits: data.width,
-    heightInDashboardUnits: data.height,
-    minHeightInDashboardUnits: 3,
-    minWidthInDashboardUnits: 6,
-    arguments: {
-      title: data.title,
-      description: data.description,
-      metricKind: data.metricKind,
-    },
-  };
-}
-
 // -- Dashboard configs --
 
 function createMonitorDashboardConfig(): DashboardViewConfig {
@@ -630,9 +643,25 @@ function createMonitorDashboardConfig(): DashboardViewConfig {
     }),
   ];
 
+  /*
+   * Monitor metrics are stored with bare attribute keys (`monitorName`,
+   * `probeName`) rather than the OTel `resource.*` prefix — see
+   * MonitorMetricUtil.buildAttributes — so the variable binds to the
+   * bare key. Multi-select lets users pin a small group of monitors.
+   */
+  const variables: Array<DashboardVariable> = [
+    createTelemetryAttributeVariable({
+      name: "monitor",
+      label: "Monitor",
+      attributeKey: "monitorName",
+      isMultiSelect: true,
+    }),
+  ];
+
   return {
     _type: ObjectType.DashboardViewConfig,
     components,
+    variables,
     heightInDashboardUnits: Math.max(DashboardSize.heightInDashboardUnits, 13),
   };
 }
@@ -1122,9 +1151,31 @@ function createKubernetesDashboardConfig(): DashboardViewConfig {
     }),
   ];
 
+  /*
+   * Pre-built variables let the user scope every widget on the dashboard
+   * to a single cluster / namespace from the toolbar. Multi-select is on
+   * for namespace so users can pick a couple of namespaces at once;
+   * cluster stays single-select since the typical "compare two clusters"
+   * workflow lives on the Compare page.
+   */
+  const variables: Array<DashboardVariable> = [
+    createTelemetryAttributeVariable({
+      name: "cluster",
+      label: "Cluster",
+      attributeKey: "resource.k8s.cluster.name",
+    }),
+    createTelemetryAttributeVariable({
+      name: "namespace",
+      label: "Namespace",
+      attributeKey: "resource.k8s.namespace.name",
+      isMultiSelect: true,
+    }),
+  ];
+
   return {
     _type: ObjectType.DashboardViewConfig,
     components,
+    variables,
     heightInDashboardUnits: Math.max(DashboardSize.heightInDashboardUnits, 21),
   };
 }
@@ -1442,9 +1493,25 @@ function createMetricsDashboardConfig(): DashboardViewConfig {
     }),
   ];
 
+  /*
+   * Most HTTP / runtime metrics on this dashboard carry the standard
+   * OTel `resource.service.name` attribute, so scoping by service is
+   * the most useful default. Multi-select keeps the cross-service view
+   * available — e.g. compare API and worker on one chart.
+   */
+  const variables: Array<DashboardVariable> = [
+    createTelemetryAttributeVariable({
+      name: "service",
+      label: "Service",
+      attributeKey: "resource.service.name",
+      isMultiSelect: true,
+    }),
+  ];
+
   return {
     _type: ObjectType.DashboardViewConfig,
     components,
+    variables,
     heightInDashboardUnits: Math.max(DashboardSize.heightInDashboardUnits, 24),
   };
 }
@@ -1453,11 +1520,10 @@ function createHostDashboardConfig(): DashboardViewConfig {
   /*
    * Layout notes:
    *
-   * - The HostMetricChart widget groups by `host.name` and plots one
-   *   series per host (or a single series when filtered to one host).
-   *   The OTel host receiver emits `system.cpu.utilization` and
-   *   `system.memory.utilization` as [0, 1] ratios, which Value/Gauge
-   *   widgets auto-scale to percent at render time (see
+   * - Per-host charts fan out via `groupByAttributeKeys: ["host.name"]`
+   *   so a single chart renders one series per host. The OTel host
+   *   receiver emits `system.cpu.utilization` as a [0, 1] ratio, which
+   *   Value/Gauge widgets auto-scale to percent at render time (see
    *   splitFormattedValue / isFractionScale).
    *
    * - The Value widget for "Avg Memory" uses `system.memory.usage`
@@ -1465,11 +1531,10 @@ function createHostDashboardConfig(): DashboardViewConfig {
    *   `system.memory.utilization` is not always emitted by default OTel
    *   host metrics.
    *
-   * - Disk and Network I/O Value widgets aggregate the raw byte counters
-   *   with Sum. HostMetricChart turns these into per-second rates for
-   *   the chart view; the Value tile shows the unrated total so users
-   *   reading "Disk I/O" against the time window get an absolute byte
-   *   figure rather than a noisy snapshot.
+   * - Disk and Network I/O charts set `transformAsRate: true` so the
+   *   cumulative byte counters render as per-second rates rather than
+   *   bytes-since-boot. The matching Value tiles in row 1 keep the
+   *   unrated Sum so users see an absolute byte figure over the window.
    */
   const components: Array<DashboardBaseComponent> = [
     // Row 0: Title
@@ -1529,21 +1594,31 @@ function createHostDashboardConfig(): DashboardViewConfig {
     }),
 
     // Row 2-4: Per-host CPU and Memory charts
-    createHostMetricChartComponent({
+    createChartComponent({
       title: "CPU Utilization by Host",
-      metricKind: HostMetricKind.CpuUtilization,
+      chartType: DashboardChartType.Line,
       top: 2,
       left: 0,
       width: 6,
       height: 3,
+      metricConfig: {
+        metricName: MetricDashboardMetricType.SystemCpuUtilization,
+        aggregationType: MetricsAggregationType.Avg,
+        groupByAttributeKeys: ["host.name"],
+      },
     }),
-    createHostMetricChartComponent({
+    createChartComponent({
       title: "Memory Usage by Host",
-      metricKind: HostMetricKind.MemoryUsage,
+      chartType: DashboardChartType.Line,
       top: 2,
       left: 6,
       width: 6,
       height: 3,
+      metricConfig: {
+        metricName: MetricDashboardMetricType.SystemMemoryUsage,
+        aggregationType: MetricsAggregationType.Avg,
+        groupByAttributeKeys: ["host.name"],
+      },
     }),
 
     // Row 5: Section header
@@ -1600,13 +1675,18 @@ function createHostDashboardConfig(): DashboardViewConfig {
         aggregationType: MetricsAggregationType.Avg,
       },
     }),
-    createHostMetricChartComponent({
+    createChartComponent({
       title: "Filesystem Usage by Host",
-      metricKind: HostMetricKind.Filesystem,
+      chartType: DashboardChartType.Line,
       top: 11,
       left: 4,
       width: 8,
       height: 3,
+      metricConfig: {
+        metricName: "system.filesystem.usage",
+        aggregationType: MetricsAggregationType.Avg,
+        groupByAttributeKeys: ["host.name"],
+      },
     }),
 
     // Row 14: Section header
@@ -1620,21 +1700,33 @@ function createHostDashboardConfig(): DashboardViewConfig {
     }),
 
     // Row 15-17: Disk and network I/O rates per host
-    createHostMetricChartComponent({
+    createChartComponent({
       title: "Disk I/O by Host",
-      metricKind: HostMetricKind.DiskIo,
+      chartType: DashboardChartType.Line,
       top: 15,
       left: 0,
       width: 6,
       height: 3,
+      metricConfig: {
+        metricName: MetricDashboardMetricType.SystemDiskIo,
+        aggregationType: MetricsAggregationType.Sum,
+        groupByAttributeKeys: ["host.name"],
+        transformAsRate: true,
+      },
     }),
-    createHostMetricChartComponent({
+    createChartComponent({
       title: "Network I/O by Host",
-      metricKind: HostMetricKind.NetworkIo,
+      chartType: DashboardChartType.Line,
       top: 15,
       left: 6,
       width: 6,
       height: 3,
+      metricConfig: {
+        metricName: MetricDashboardMetricType.SystemNetworkIo,
+        aggregationType: MetricsAggregationType.Sum,
+        groupByAttributeKeys: ["host.name"],
+        transformAsRate: true,
+      },
     }),
 
     // Row 18: Section header
@@ -1648,13 +1740,18 @@ function createHostDashboardConfig(): DashboardViewConfig {
     }),
 
     // Row 19-21: Process count chart and recent logs
-    createHostMetricChartComponent({
+    createChartComponent({
       title: "Process Count by Host",
-      metricKind: HostMetricKind.ProcessCount,
+      chartType: DashboardChartType.Line,
       top: 19,
       left: 0,
       width: 6,
       height: 3,
+      metricConfig: {
+        metricName: "system.processes.count",
+        aggregationType: MetricsAggregationType.Avg,
+        groupByAttributeKeys: ["host.name"],
+      },
     }),
     createLogStreamComponent({
       title: "Recent Logs",
@@ -1665,9 +1762,25 @@ function createHostDashboardConfig(): DashboardViewConfig {
     }),
   ];
 
+  /*
+   * Per-host scoping: the variable defaults to multi-select because the
+   * dashboard's by-host charts already split rendering per host; the
+   * selector lets users narrow to a subset (e.g. just two prod hosts)
+   * without losing the per-host breakdown.
+   */
+  const variables: Array<DashboardVariable> = [
+    createTelemetryAttributeVariable({
+      name: "host",
+      label: "Host",
+      attributeKey: "resource.host.name",
+      isMultiSelect: true,
+    }),
+  ];
+
   return {
     _type: ObjectType.DashboardViewConfig,
     components,
+    variables,
     heightInDashboardUnits: Math.max(DashboardSize.heightInDashboardUnits, 22),
   };
 }

package/Types/Monitor/MonitorType.ts

@@ -83,7 +83,7 @@ export class MonitorTypeHelper {
       },
       {
         label: "Infrastructure",
-        monitorTypes: [MonitorType.Server, MonitorType.SNMP],
+        monitorTypes: [MonitorType.SNMP],
       },
       {
         label: "Kubernetes",

package/Types/OnCallDutyPolicy/UserOverrideUtil.ts

@@ -27,22 +27,49 @@ export const OVERRIDE_META_KEY: string = "_override";
 
 export default class UserOverrideUtil {
   /**
-   * Returns true when this override should be applied on top of the schedule
-   * events. Global overrides always apply; policy-scoped overrides apply to
-   * any schedule, since a schedule's calendar shows coverage information for
-   * every user who could potentially be paged through it.
+   * Decides whether an override should affect resolution for a given policy
+   * context. Global overrides (no policy id) always apply. Policy-scoped
+   * overrides only apply when their policy matches the caller's policy.
+   * When the caller has no policy context, only global overrides apply.
    */
-  public static isOverrideApplicable(_override: UserOverrideRecord): boolean {
-    return true;
+  public static isOverrideApplicable(
+    override: UserOverrideRecord,
+    currentOnCallDutyPolicyId?: string | null | undefined,
+  ): boolean {
+    if (!override.onCallDutyPolicyId) {
+      return true;
+    }
+
+    if (!currentOnCallDutyPolicyId) {
+      return false;
+    }
+
+    return override.onCallDutyPolicyId === currentOnCallDutyPolicyId;
   }
 
   public static applyOverridesToEvents(data: {
     events: Array<CalendarEvent>;
     overrides: Array<UserOverrideRecord>;
+    currentOnCallDutyPolicyId?: string | null | undefined;
   }): Array<CalendarEvent> {
-    const applicable: Array<UserOverrideRecord> = data.overrides.filter(
-      UserOverrideUtil.isOverrideApplicable,
-    );
+    const applicable: Array<UserOverrideRecord> = data.overrides
+      .filter((o: UserOverrideRecord) => {
+        return UserOverrideUtil.isOverrideApplicable(
+          o,
+          data.currentOnCallDutyPolicyId,
+        );
+      })
+      /*
+       * Apply policy-specific overrides before globals so that when both
+       * target the same user/window, the policy-specific substitution wins.
+       * splitEventByOverride only matches on the original user id, so the
+       * first override that consumes a segment claims it.
+       */
+      .sort((a: UserOverrideRecord, b: UserOverrideRecord) => {
+        const aPolicyScoped: number = a.onCallDutyPolicyId ? 0 : 1;
+        const bPolicyScoped: number = b.onCallDutyPolicyId ? 0 : 1;
+        return aPolicyScoped - bPolicyScoped;
+      });
 
     if (applicable.length === 0) {
       return data.events;

package/Utils/Dashboard/Components/DashboardTableComponent.ts

@@ -1,5 +1,9 @@
-import DashboardTableComponent from "../../../Types/Dashboard/DashboardComponents/DashboardTableComponent";
+import DashboardTableComponent, {
+  TableColumnKind,
+  TableReduce,
+} from "../../../Types/Dashboard/DashboardComponents/DashboardTableComponent";
 import { ObjectType } from "../../../Types/JSON";
+import MetricsAggregationType from "../../../Types/Metrics/MetricsAggregationType";
 import ObjectID from "../../../Types/ObjectID";
 import DashboardBaseComponentUtil from "./DashboardBaseComponent";
 import {
@@ -9,15 +13,16 @@ import {
 } from "../../../Types/Dashboard/DashboardComponents/ComponentArgument";
 import DashboardComponentType from "../../../Types/Dashboard/DashboardComponentType";
 
-const DataSourceSection: ComponentArgumentSection = {
-  name: "Data Source",
-  description: "Configure which metrics to display in the table",
+const DataSection: ComponentArgumentSection = {
+  name: "Data",
+  description:
+    "Pick how rows are grouped, then add columns for metrics and formulas",
   order: 1,
 };
 
 const DisplaySection: ComponentArgumentSection = {
   name: "Display Options",
-  description: "Customize the table appearance",
+  description: "Customize how the table renders",
   order: 2,
   defaultCollapsed: true,
 };
@@ -35,13 +40,22 @@ export default class DashboardTableComponentUtil extends DashboardBaseComponentU
       minHeightInDashboardUnits: 3,
       minWidthInDashboardUnits: 4,
       arguments: {
-        metricQueryConfig: {
-          metricQueryData: {
-            filterData: {},
-            groupBy: undefined,
+        groupByAttributes: [],
+        columns: [
+          {
+            id: ObjectID.generate().toString(),
+            variable: "a",
+            header: "Value",
+            kind: TableColumnKind.Metric,
+            showAsColumn: true,
+            metricName: undefined,
+            aggregation: MetricsAggregationType.Avg,
+            decimals: 2,
           },
-        },
-        maxRows: 20,
+        ],
+        maxRows: 25,
+        reduce: TableReduce.Last,
+        decimals: 2,
       },
     };
   }
@@ -54,12 +68,23 @@ export default class DashboardTableComponentUtil extends DashboardBaseComponentU
     > = [];
 
     componentArguments.push({
-      name: "Metric Query",
-      description: "Select the metrics to display in the table",
+      name: "Group By Attributes",
+      description:
+        "Each unique combination of these attribute values becomes one row. Customize the column header for each picked attribute below. Leave empty for a time-bucketed table.",
+      required: false,
+      type: ComponentInputType.TableGroupBy,
+      id: "groupByAttributes",
+      section: DataSection,
+    });
+
+    componentArguments.push({
+      name: "Metrics & Columns",
+      description:
+        "Define metrics (data sources) and formulas. Each is auto-assigned a variable letter (a, b, c…) — formulas reference these. Toggle 'Show as column' off for metrics that should only feed formulas without appearing in the table.",
       required: true,
-      type: ComponentInputType.MetricsQueryConfig,
-      id: "metricQueryConfig",
-      section: DataSourceSection,
+      type: ComponentInputType.TableColumns,
+      id: "columns",
+      section: DataSection,
     });
 
     componentArguments.push({
@@ -71,13 +96,51 @@ export default class DashboardTableComponentUtil extends DashboardBaseComponentU
       section: DisplaySection,
     });
 
+    componentArguments.push({
+      name: "Description",
+      description: "Subtitle shown below the title",
+      required: false,
+      type: ComponentInputType.LongText,
+      id: "tableDescription",
+      section: DisplaySection,
+    });
+
+    componentArguments.push({
+      name: "Reduce across time",
+      description:
+        "When Group By is set, how to collapse the time series into one value per row",
+      required: false,
+      type: ComponentInputType.Dropdown,
+      id: "reduce",
+      placeholder: TableReduce.Last,
+      section: DisplaySection,
+      dropdownOptions: [
+        { label: "Last value", value: TableReduce.Last },
+        { label: "Average", value: TableReduce.Avg },
+        { label: "Sum", value: TableReduce.Sum },
+        { label: "Min", value: TableReduce.Min },
+        { label: "Max", value: TableReduce.Max },
+      ],
+    });
+
+    componentArguments.push({
+      name: "Decimals",
+      description:
+        "Default decimals for value columns (overridable per column)",
+      required: false,
+      type: ComponentInputType.Number,
+      id: "decimals",
+      placeholder: "2",
+      section: DisplaySection,
+    });
+
     componentArguments.push({
       name: "Max Rows",
       description: "Maximum number of rows to show",
       required: false,
       type: ComponentInputType.Number,
       id: "maxRows",
-      placeholder: "20",
+      placeholder: "25",
       section: DisplaySection,
     });
 

package/Utils/Dashboard/Components/Index.ts

@@ -11,7 +11,6 @@ import DashboardDockerNetworkListComponentUtil from "./DashboardDockerNetworkLis
 import DashboardDockerVolumeListComponentUtil from "./DashboardDockerVolumeListComponent";
 import DashboardGaugeComponentUtil from "./DashboardGaugeComponent";
 import DashboardHostListComponentUtil from "./DashboardHostListComponent";
-import DashboardHostMetricChartComponentUtil from "./DashboardHostMetricChartComponent";
 import DashboardIncidentListComponentUtil from "./DashboardIncidentListComponent";
 import DashboardKubernetesCronJobListComponentUtil from "./DashboardKubernetesCronJobListComponent";
 import DashboardKubernetesDaemonSetListComponentUtil from "./DashboardKubernetesDaemonSetListComponent";
@@ -187,12 +186,6 @@ export default class DashboardComponentsUtil {
       >;
     }
 
-    if (dashboardComponentType === DashboardComponentType.HostMetricChart) {
-      return DashboardHostMetricChartComponentUtil.getComponentConfigArguments() as Array<
-        ComponentArgument<DashboardBaseComponent>
-      >;
-    }
-
     throw new BadDataException(
       `Unknown dashboard component type: ${dashboardComponentType}`,
     );