@oneuptime/common 11.3.9 → 11.3.11

package/Tests/Server/Services/AnalyticsDatabaseService.test.ts

@@ -13,6 +13,8 @@ import TableColumnType from "../../../Types/AnalyticsDatabase/TableColumnType";
 import AggregationType from "../../../Types/BaseDatabase/AggregationType";
 import BadDataException from "../../../Types/Exception/BadDataException";
 import GenericObject from "../../../Types/GenericObject";
+import ObjectID from "../../../Types/ObjectID";
+import OneUptimeDate from "../../../Types/Date";
 import {
   describe,
   expect,
@@ -379,6 +381,149 @@ describe("AnalyticsDatabaseService", () => {
    * ids per call. Must be strictly additive: option-less calls keep the
    * exact pre-existing exec/query payload.
    */
+  /*
+   * Required-field validation. A required column is satisfied by any present
+   * value (including the boolean `false`); only null/undefined triggers a
+   * default-fill or a "<field> is required" error. This is regression coverage
+   * for the boolean branch that previously rejected every required Boolean
+   * column (both true and false), which made models like MutableMetric — whose
+   * `isDeleted` tombstone flag is a required Boolean — impossible to insert.
+   */
+  describe("checkRequiredFields", () => {
+    class RequiredFieldsModel extends AnalyticsBaseModel {
+      public constructor() {
+        super({
+          tableName: "<required-fields-table>",
+          singularName: "<singular-name>",
+          pluralName: "<plural-name>",
+          tableColumns: [
+            new AnalyticsTableColumn({
+              key: "requiredText",
+              title: "<title>",
+              description: "<description>",
+              required: true,
+              type: TableColumnType.Text,
+            }),
+            new AnalyticsTableColumn({
+              key: "requiredBoolWithDefault",
+              title: "<title>",
+              description: "<description>",
+              required: true,
+              type: TableColumnType.Boolean,
+              defaultValue: false,
+            }),
+          ],
+          crudApiPath: new Route("route"),
+          primaryKeys: ["requiredText"],
+          sortKeys: ["requiredText"],
+          partitionKey: "requiredText",
+          tableEngine: AnalyticsTableEngine.MergeTree,
+        });
+      }
+
+      /*
+       * checkRequiredFields reads columns via property accessors, so the model
+       * must expose getters/setters that delegate to get/setColumnValue (real
+       * analytics models do the same for every column).
+       */
+      public get requiredText(): string | undefined {
+        return this.getColumnValue("requiredText") as string | undefined;
+      }
+      public set requiredText(v: string | undefined) {
+        this.setColumnValue("requiredText", v);
+      }
+      public get requiredBoolWithDefault(): boolean | undefined {
+        return this.getColumnValue("requiredBoolWithDefault") as
+          | boolean
+          | undefined;
+      }
+      public set requiredBoolWithDefault(v: boolean | undefined) {
+        this.setColumnValue("requiredBoolWithDefault", v);
+      }
+    }
+
+    let requiredFieldsService: AnalyticsDatabaseService<RequiredFieldsModel>;
+
+    beforeEach(() => {
+      requiredFieldsService = new AnalyticsDatabaseService({
+        modelType: RequiredFieldsModel,
+      });
+    });
+
+    // Build a model with every required column satisfied except as overridden.
+    const buildModel: (
+      overrides?: (model: RequiredFieldsModel) => void,
+    ) => RequiredFieldsModel = (
+      overrides?: (model: RequiredFieldsModel) => void,
+    ): RequiredFieldsModel => {
+      const model: RequiredFieldsModel = new RequiredFieldsModel();
+      // _id and createdAt are required on the base model and carry no default.
+      model.setColumnValue("_id", ObjectID.generate());
+      model.setColumnValue("createdAt", OneUptimeDate.getCurrentDate());
+      model.setColumnValue("requiredText", "value");
+      if (overrides) {
+        overrides(model);
+      }
+      return model;
+    };
+
+    const check: (model: RequiredFieldsModel) => RequiredFieldsModel = (
+      model: RequiredFieldsModel,
+    ): RequiredFieldsModel => {
+      return (requiredFieldsService as any).checkRequiredFields(model);
+    };
+
+    test("accepts a required boolean set to false (regression)", () => {
+      const model: RequiredFieldsModel = buildModel(
+        (m: RequiredFieldsModel): void => {
+          m.setColumnValue("requiredBoolWithDefault", false);
+        },
+      );
+
+      expect(() => {
+        return check(model);
+      }).not.toThrow();
+      expect(model.getColumnValue("requiredBoolWithDefault")).toBe(false);
+    });
+
+    test("accepts a required boolean set to true", () => {
+      const model: RequiredFieldsModel = buildModel(
+        (m: RequiredFieldsModel): void => {
+          m.setColumnValue("requiredBoolWithDefault", true);
+        },
+      );
+
+      expect(() => {
+        return check(model);
+      }).not.toThrow();
+      expect(model.getColumnValue("requiredBoolWithDefault")).toBe(true);
+    });
+
+    test("fills the default when a required boolean is unset", () => {
+      const model: RequiredFieldsModel = buildModel();
+
+      expect(() => {
+        return check(model);
+      }).not.toThrow();
+      expect(model.getColumnValue("requiredBoolWithDefault")).toBe(false);
+    });
+
+    test("throws when a required column without a default is missing", () => {
+      const model: RequiredFieldsModel = new RequiredFieldsModel();
+      model.setColumnValue("_id", ObjectID.generate());
+      model.setColumnValue("createdAt", OneUptimeDate.getCurrentDate());
+      model.setColumnValue("requiredBoolWithDefault", false);
+      // requiredText (required, no default) intentionally left unset.
+
+      expect(() => {
+        return check(model);
+      }).toThrow(BadDataException);
+      expect(() => {
+        return check(model);
+      }).toThrow("requiredText is required");
+    });
+  });
+
   describe("execute / executeQuery per-call options", () => {
     let exec: ReturnType<typeof jest.fn>;
     let query: ReturnType<typeof jest.fn>;

package/Tests/Types/Monitor/MonitorStepEntityScope.test.ts

@@ -4,7 +4,6 @@ import Log from "../../../Models/AnalyticsModels/Log";
 import Span from "../../../Models/AnalyticsModels/Span";
 import ExceptionInstance from "../../../Models/AnalyticsModels/ExceptionInstance";
 import Profile from "../../../Models/AnalyticsModels/Profile";
-import Metric from "../../../Models/AnalyticsModels/Metric";
 import MonitorStepLogMonitor, {
   MonitorStepLogMonitorUtil,
 } from "../../../Types/Monitor/MonitorStepLogMonitor";
@@ -17,9 +16,6 @@ import MonitorStepExceptionMonitor, {
 import MonitorStepProfileMonitor, {
   MonitorStepProfileMonitorUtil,
 } from "../../../Types/Monitor/MonitorStepProfileMonitor";
-import MonitorStepMetricMonitor, {
-  MonitorStepMetricMonitorUtil,
-} from "../../../Types/Monitor/MonitorStepMetricMonitor";
 import { JSONObject } from "../../../Types/JSON";
 
 /*
@@ -221,55 +217,3 @@ describe("MonitorStepProfileMonitorUtil.toQuery entity scoping", () => {
     expectIncludes(query.entityKeys, TWO_KEYS);
   });
 });
-
-describe("MonitorStepMetricMonitorUtil.applyEntityScopeToQuery", () => {
-  test("is a no-op when entityKeys is undefined (pre-existing saved monitors)", () => {
-    const step: MonitorStepMetricMonitor =
-      MonitorStepMetricMonitorUtil.getDefault();
-    delete step.entityKeys;
-
-    const query: Query<Metric> = {};
-    MonitorStepMetricMonitorUtil.applyEntityScopeToQuery(query, step);
-
-    expect(query.entityKeys).toBeUndefined();
-    expect(Object.keys(query)).toHaveLength(0);
-  });
-
-  test("is a no-op when entityKeys is an empty array", () => {
-    const step: MonitorStepMetricMonitor =
-      MonitorStepMetricMonitorUtil.getDefault();
-    step.entityKeys = [];
-
-    const query: Query<Metric> = {};
-    MonitorStepMetricMonitorUtil.applyEntityScopeToQuery(query, step);
-
-    expect(query.entityKeys).toBeUndefined();
-  });
-
-  test("stamps an Includes on entityKeys for two keys and preserves other predicates", () => {
-    const step: MonitorStepMetricMonitor =
-      MonitorStepMetricMonitorUtil.getDefault();
-    step.entityKeys = TWO_KEYS;
-
-    const query: Query<Metric> = { name: "cpu.usage" };
-    const returned: Query<Metric> =
-      MonitorStepMetricMonitorUtil.applyEntityScopeToQuery(query, step);
-
-    expect(returned).toBe(query);
-    expect(query.name).toBe("cpu.usage");
-    expectIncludes(query.entityKeys, TWO_KEYS);
-  });
-
-  test("fromJSON preserves entityKeys (pass-through serialization)", () => {
-    const step: MonitorStepMetricMonitor =
-      MonitorStepMetricMonitorUtil.getDefault();
-    step.entityKeys = TWO_KEYS;
-
-    const roundTripped: MonitorStepMetricMonitor =
-      MonitorStepMetricMonitorUtil.fromJSON(
-        MonitorStepMetricMonitorUtil.toJSON(step),
-      );
-
-    expect(roundTripped.entityKeys).toEqual(TWO_KEYS);
-  });
-});

package/Types/AnalyticsDatabase/AnalyticsTableEngine.ts

@@ -1,5 +1,6 @@
 enum AnalyticsTableEngine {
   MergeTree = "MergeTree",
+  ReplacingMergeTree = "ReplacingMergeTree",
   /*
    * Target-table engine for materialized views that store
    * AggregateFunction states. Background merges combine partial state

package/Types/AnalyticsDatabase/AnalyticsTableName.ts

@@ -21,6 +21,7 @@ enum AnalyticsTableName {
    */
   MetricItemAggMV1mByHostV2 = "MetricItemAggMV1mByHostV2",
   MetricBaselineHourly = "MetricBaselineHourly",
+  MutableMetric = "MutableMetricItem",
 }
 
 export default AnalyticsTableName;

package/Types/Dashboard/DashboardTemplates.ts

@@ -9,6 +9,7 @@ import DashboardVariable, { DashboardVariableType } from "./DashboardVariable";
 import IconProp from "../Icon/IconProp";
 import MetricsAggregationType from "../Metrics/MetricsAggregationType";
 import IncidentMetricType from "../Incident/IncidentMetricType";
+import AlertMetricType from "../Alerts/AlertMetricType";
 import MonitorMetricType from "../Monitor/MonitorMetricType";
 import MetricDashboardMetricType from "../Metrics/MetricDashboardMetricType";
 import { DashboardValueTrendDirection } from "./DashboardComponents/DashboardValueComponent";
@@ -24,6 +25,7 @@ export enum DashboardTemplateType {
   Blank = "Blank",
   Monitor = "Monitor",
   Incident = "Incident",
+  Alert = "Alert",
   Kubernetes = "Kubernetes",
   Host = "Host",
   Proxmox = "Proxmox",
@@ -32,11 +34,32 @@ export enum DashboardTemplateType {
   Metrics = "Metrics",
 }
 
+/*
+ * Templates are grouped into categories so the "Create from Template"
+ * modal can render them under labelled sections instead of one flat
+ * grid. The enum values double as the section headings, and
+ * DashboardTemplateCategories below fixes the display order.
+ */
+export enum DashboardTemplateCategory {
+  GetStarted = "Get Started",
+  Monitoring = "Monitoring & APM",
+  IncidentResponse = "Incident Response",
+  Infrastructure = "Infrastructure",
+}
+
+export const DashboardTemplateCategories: Array<DashboardTemplateCategory> = [
+  DashboardTemplateCategory.GetStarted,
+  DashboardTemplateCategory.Monitoring,
+  DashboardTemplateCategory.IncidentResponse,
+  DashboardTemplateCategory.Infrastructure,
+];
+
 export interface DashboardTemplate {
   type: DashboardTemplateType;
   name: string;
   description: string;
   icon: IconProp;
+  category: DashboardTemplateCategory;
 }
 
 export const DashboardTemplates: Array<DashboardTemplate> = [
@@ -45,6 +68,7 @@ export const DashboardTemplates: Array<DashboardTemplate> = [
     name: "Blank Dashboard",
     description: "Start from scratch with an empty dashboard.",
     icon: IconProp.Add,
+    category: DashboardTemplateCategory.GetStarted,
   },
   {
     type: DashboardTemplateType.Monitor,
@@ -52,6 +76,15 @@ export const DashboardTemplates: Array<DashboardTemplate> = [
     description:
       "Response time, uptime, status codes, CPU/memory health gauges, and breakdown table for synthetic and server monitors.",
     icon: IconProp.Heartbeat,
+    category: DashboardTemplateCategory.Monitoring,
+  },
+  {
+    type: DashboardTemplateType.Metrics,
+    name: "Metrics Dashboard",
+    description:
+      "HTTP request rate, latency, error rate, CPU utilization gauge, memory usage, disk and network I/O, and runtime metrics.",
+    icon: IconProp.ChartBar,
+    category: DashboardTemplateCategory.Monitoring,
   },
   {
     type: DashboardTemplateType.Incident,
@@ -59,6 +92,15 @@ export const DashboardTemplates: Array<DashboardTemplate> = [
     description:
       "Incident count, MTTR/MTTA gauges, duration trends, severity breakdown, time-in-state, and longest-incident tables.",
     icon: IconProp.Alert,
+    category: DashboardTemplateCategory.IncidentResponse,
+  },
+  {
+    type: DashboardTemplateType.Alert,
+    name: "Alert Dashboard",
+    description:
+      "Alert count, MTTR/MTTA gauges, duration trends, alert volume over time, and longest-alert / acknowledgement tables.",
+    icon: IconProp.Bell,
+    category: DashboardTemplateCategory.IncidentResponse,
   },
   {
     type: DashboardTemplateType.Kubernetes,
@@ -66,6 +108,7 @@ export const DashboardTemplates: Array<DashboardTemplate> = [
     description:
       "Pod/node CPU and memory averages, utilization gauges, live pod and node lists, network I/O, restarts, and cluster logs.",
     icon: IconProp.Kubernetes,
+    category: DashboardTemplateCategory.Infrastructure,
   },
   {
     type: DashboardTemplateType.Host,
@@ -73,6 +116,7 @@ export const DashboardTemplates: Array<DashboardTemplate> = [
     description:
       "Per-host CPU, memory, disk and network charts, a live host inventory, CPU utilization gauge, process counts, and recent logs.",
     icon: IconProp.Server,
+    category: DashboardTemplateCategory.Infrastructure,
   },
   {
     type: DashboardTemplateType.Proxmox,
@@ -80,6 +124,7 @@ export const DashboardTemplates: Array<DashboardTemplate> = [
     description:
       "Live node and guest inventories with status, CPU/memory trends, network throughput, and cluster logs.",
     icon: IconProp.ServerStack,
+    category: DashboardTemplateCategory.Infrastructure,
   },
   {
     type: DashboardTemplateType.Ceph,
@@ -87,6 +132,7 @@ export const DashboardTemplates: Array<DashboardTemplate> = [
     description:
       "OSD wall and pool capacity lists, health and capacity stats, degraded-PG trends, client throughput, and cluster logs.",
     icon: IconProp.Database,
+    category: DashboardTemplateCategory.Infrastructure,
   },
   {
     type: DashboardTemplateType.DockerSwarm,
@@ -94,16 +140,22 @@ export const DashboardTemplates: Array<DashboardTemplate> = [
     description:
       "Live node and service inventories with role/status, container CPU and memory trends, PID counts, and cluster logs.",
     icon: IconProp.Cube,
-  },
-  {
-    type: DashboardTemplateType.Metrics,
-    name: "Metrics Dashboard",
-    description:
-      "HTTP request rate, latency, error rate, CPU utilization gauge, memory usage, disk and network I/O, and runtime metrics.",
-    icon: IconProp.ChartBar,
+    category: DashboardTemplateCategory.Infrastructure,
   },
 ];
 
+/*
+ * Templates for a category in their declared order. The modal uses this
+ * to render one labelled section per category.
+ */
+export function getDashboardTemplatesByCategory(
+  category: DashboardTemplateCategory,
+): Array<DashboardTemplate> {
+  return DashboardTemplates.filter((template: DashboardTemplate): boolean => {
+    return template.category === category;
+  });
+}
+
 // -- Metric query config helpers --
 
 interface MetricConfig {
@@ -1105,6 +1157,212 @@ function createIncidentDashboardConfig(): DashboardViewConfig {
   };
 }
 
+function createAlertDashboardConfig(): DashboardViewConfig {
+  /*
+   * Alert metrics (TimeToResolve, TimeToAcknowledge, AlertDuration) are
+   * emitted with unit "seconds" by AlertService, and AlertCount is a
+   * unitless "1 per alert" counter — the same shape as the Incident
+   * metrics. As with the Incident template we drop legendUnit overrides
+   * (ValueFormatter scales `seconds` to sec/min/hr based on magnitude)
+   * and author the MTTR/MTTA gauge ranges in seconds so the 0-100% sweep
+   * is meaningful.
+   *
+   * Alerts have a leaner metric catalog than incidents: there are no
+   * severity-change, time-in-state, or postmortem metrics, so this
+   * template trades those widgets for the four alert metrics that are
+   * actually emitted.
+   */
+  const components: Array<DashboardBaseComponent> = [
+    // Row 0: Title
+    createTextComponent({
+      text: "Alert Dashboard",
+      top: 0,
+      left: 0,
+      width: 12,
+      height: 1,
+      isBold: true,
+    }),
+
+    // Row 1: Key alert metrics — every one is "higher = worse".
+    createValueComponent({
+      title: "Alert Count",
+      top: 1,
+      left: 0,
+      width: 3,
+      metricConfig: {
+        metricName: AlertMetricType.AlertCount,
+        aggregationType: MetricsAggregationType.Sum,
+      },
+      trendDirection: DashboardValueTrendDirection.HigherIsWorse,
+    }),
+    createValueComponent({
+      title: "MTTR",
+      top: 1,
+      left: 3,
+      width: 3,
+      metricConfig: {
+        metricName: AlertMetricType.TimeToResolve,
+        aggregationType: MetricsAggregationType.Avg,
+      },
+      trendDirection: DashboardValueTrendDirection.HigherIsWorse,
+    }),
+    createValueComponent({
+      title: "MTTA",
+      top: 1,
+      left: 6,
+      width: 3,
+      metricConfig: {
+        metricName: AlertMetricType.TimeToAcknowledge,
+        aggregationType: MetricsAggregationType.Avg,
+      },
+      trendDirection: DashboardValueTrendDirection.HigherIsWorse,
+    }),
+    createValueComponent({
+      title: "Avg Duration",
+      top: 1,
+      left: 9,
+      width: 3,
+      metricConfig: {
+        metricName: AlertMetricType.AlertDuration,
+        aggregationType: MetricsAggregationType.Avg,
+      },
+      trendDirection: DashboardValueTrendDirection.HigherIsWorse,
+    }),
+
+    // Row 2-4: Alert trends
+    createChartComponent({
+      title: "Alerts Over Time",
+      chartType: DashboardChartType.Bar,
+      top: 2,
+      left: 0,
+      width: 6,
+      height: 3,
+      metricConfig: {
+        metricName: AlertMetricType.AlertCount,
+        aggregationType: MetricsAggregationType.Sum,
+        legend: "Alerts",
+      },
+    }),
+    createChartComponent({
+      title: "Alert Duration Over Time",
+      chartType: DashboardChartType.Line,
+      top: 2,
+      left: 6,
+      width: 6,
+      height: 3,
+      metricConfig: {
+        metricName: AlertMetricType.AlertDuration,
+        aggregationType: MetricsAggregationType.Avg,
+        legend: "Avg Duration",
+      },
+    }),
+
+    // Row 5: Section header
+    createTextComponent({
+      text: "Response Performance",
+      top: 5,
+      left: 0,
+      width: 12,
+      height: 1,
+      isBold: true,
+    }),
+
+    /*
+     * Row 6-8: MTTR/MTTA gauges. Ranges and thresholds are in seconds
+     * (matching the stored metric unit) and mirror the Incident
+     * template: MTTR full scale 2 hours (warn 1 hour, critical 1.5
+     * hours); MTTA full scale 1 hour (warn 15 min, critical 30 min).
+     */
+    createGaugeComponent({
+      title: "MTTR",
+      top: 6,
+      left: 0,
+      width: 3,
+      height: 3,
+      minValue: 0,
+      maxValue: 7200,
+      warningThreshold: 3600,
+      criticalThreshold: 5400,
+      metricConfig: {
+        metricName: AlertMetricType.TimeToResolve,
+        aggregationType: MetricsAggregationType.Avg,
+      },
+    }),
+    createGaugeComponent({
+      title: "MTTA",
+      top: 6,
+      left: 3,
+      width: 3,
+      height: 3,
+      minValue: 0,
+      maxValue: 3600,
+      warningThreshold: 900,
+      criticalThreshold: 1800,
+      metricConfig: {
+        metricName: AlertMetricType.TimeToAcknowledge,
+        aggregationType: MetricsAggregationType.Avg,
+      },
+    }),
+    createChartComponent({
+      title: "MTTR and MTTA Over Time",
+      chartType: DashboardChartType.Area,
+      top: 6,
+      left: 6,
+      width: 6,
+      height: 3,
+      metricConfig: {
+        metricName: AlertMetricType.TimeToResolve,
+        aggregationType: MetricsAggregationType.Avg,
+        legend: "MTTR",
+      },
+    }),
+
+    // Row 9: Section header
+    createTextComponent({
+      text: "Alert Details",
+      top: 9,
+      left: 0,
+      width: 12,
+      height: 1,
+      isBold: true,
+    }),
+
+    /*
+     * Row 10-12: Operational tables. Like the Incident template, logs /
+     * traces are intentionally absent — alert records are rows in
+     * Postgres, not log/trace sources.
+     */
+    createTableComponent({
+      title: "Alerts by Duration",
+      top: 10,
+      left: 0,
+      width: 6,
+      height: 3,
+      metricConfig: {
+        metricName: AlertMetricType.AlertDuration,
+        aggregationType: MetricsAggregationType.Max,
+      },
+    }),
+    createTableComponent({
+      title: "Time to Acknowledge",
+      top: 10,
+      left: 6,
+      width: 6,
+      height: 3,
+      metricConfig: {
+        metricName: AlertMetricType.TimeToAcknowledge,
+        aggregationType: MetricsAggregationType.Avg,
+      },
+    }),
+  ];
+
+  return {
+    _type: ObjectType.DashboardViewConfig,
+    components,
+    heightInDashboardUnits: Math.max(DashboardSize.heightInDashboardUnits, 13),
+  };
+}
+
 function createKubernetesDashboardConfig(): DashboardViewConfig {
   /*
    * Layout notes:
@@ -2427,6 +2685,8 @@ export function getTemplateConfig(
       return createMonitorDashboardConfig();
     case DashboardTemplateType.Incident:
       return createIncidentDashboardConfig();
+    case DashboardTemplateType.Alert:
+      return createAlertDashboardConfig();
     case DashboardTemplateType.Kubernetes:
       return createKubernetesDashboardConfig();
     case DashboardTemplateType.Host:

package/Types/Monitor/MonitorStepMetricMonitor.ts

@@ -1,6 +1,3 @@
-import Metric from "../../Models/AnalyticsModels/Metric";
-import Includes from "../BaseDatabase/Includes";
-import Query from "../BaseDatabase/Query";
 import { JSONObject } from "../JSON";
 import MetricsViewConfig from "../Metrics/MetricsViewConfig";
 import RollingTime from "../RollingTime/RollingTime";
@@ -8,13 +5,6 @@ import RollingTime from "../RollingTime/RollingTime";
 export default interface MonitorStepMetricMonitor {
   metricViewConfig: MetricsViewConfig;
   rollingTime: RollingTime;
-  /*
-   * Stable telemetry entity keys (host / pod / container / ...) — scopes
-   * every metric query in this step to rows carrying any of these in their
-   * entityKeys column. Optional: monitors saved before this field existed
-   * have it undefined.
-   */
-  entityKeys?: Array<string> | undefined;
 }
 
 export class MonitorStepMetricMonitorUtil {
@@ -25,26 +15,9 @@ export class MonitorStepMetricMonitorUtil {
         formulaConfigs: [],
       },
       rollingTime: RollingTime.Past1Minute,
-      entityKeys: [],
     };
   }
 
-  /*
-   * Stamps the step's entity scope onto a per-queryConfig Query<Metric>.
-   * Compiles to hasAny(entityKeys, [...]) server-side. Undefined/empty is
-   * a no-op so monitors saved before the field existed are unaffected.
-   */
-  public static applyEntityScopeToQuery(
-    query: Query<Metric>,
-    monitor: MonitorStepMetricMonitor,
-  ): Query<Metric> {
-    if (monitor.entityKeys && monitor.entityKeys.length > 0) {
-      query.entityKeys = new Includes(monitor.entityKeys);
-    }
-
-    return query;
-  }
-
   public static fromJSON(json: JSONObject): MonitorStepMetricMonitor {
     return json as any as MonitorStepMetricMonitor;
   }