@oneuptime/common 7.0.3365 → 7.0.3387

package/Server/EnvironmentConfig.ts

@@ -198,6 +198,9 @@ export const AnalyticsHost: string = process.env["ANALYTICS_HOST"] || "";
 export const DisableAutomaticIncidentCreation: boolean =
   process.env["DISABLE_AUTOMATIC_INCIDENT_CREATION"] === "true";
 
+export const DisableAutomaticAlertCreation: boolean =
+  process.env["DISABLE_AUTOMATIC_ALERT_CREATION"] === "true";
+
 export const ClickhouseHost: Hostname = Hostname.fromString(
   process.env["CLICKHOUSE_HOST"] || "clickhouse",
 );

package/Server/Services/AnalyticsDatabaseService.ts

@@ -415,6 +415,10 @@ export default class AnalyticsDatabaseService<
     strResult: string,
     columns: string[],
   ): JSONObject[] {
+    if (!strResult || !strResult.trim()) {
+      return [];
+    }
+
     const jsonItems: Array<JSONObject> = [];
 
     const rows: Array<string> = strResult.split("\n");

package/Server/Services/StatusPageService.ts

@@ -750,11 +750,11 @@ export class Service extends DatabaseService<StatusPage> {
         statusPageId: data.statusPageId,
       });
 
+    const numberOfDays: number = data.historyDays || 14;
+
     const currentDate: Date = OneUptimeDate.getCurrentDate();
-    const startDate: Date = OneUptimeDate.getSomeDaysAgo(
-      data.historyDays || 14,
-    );
-    const startAndEndDate: string = `${OneUptimeDate.getDateAsLocalFormattedString(startDate, true)} - ${OneUptimeDate.getDateAsLocalFormattedString(currentDate, true)}`;
+    const startDate: Date = OneUptimeDate.getSomeDaysAgo(numberOfDays);
+    const startAndEndDate: string = `${numberOfDays} days (${OneUptimeDate.getDateAsLocalFormattedString(startDate, true)} - ${OneUptimeDate.getDateAsLocalFormattedString(currentDate, true)})`;
 
     if (statusPageResources.length === 0) {
       return {

package/Server/Types/AnalyticsDatabase/AggregateBy.ts

@@ -2,6 +2,7 @@ import AggregationInterval from "Common/Types/BaseDatabase/AggregationInterval";
 import CommonAggregateBy from "Common/Types/BaseDatabase/AggregateBy";
 import AnalyticsBaseModel from "Common/Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
 import DatabaseCommonInteractionProps from "Common/Types/BaseDatabase/DatabaseCommonInteractionProps";
+import OneUptimeDate from "../../../Types/Date";
 
 export default interface AggregateBy<TBaseModel extends AnalyticsBaseModel>
   extends CommonAggregateBy<TBaseModel> {
@@ -13,6 +14,9 @@ export class AggregateUtil {
     startDate: Date;
     endDate: Date;
   }): AggregationInterval {
+    data.startDate = OneUptimeDate.fromString(data.startDate);
+    data.endDate = OneUptimeDate.fromString(data.endDate);
+
     const diff: number = data.endDate.getTime() - data.startDate.getTime();
 
     if (diff <= 1000 * 60 * 60 * 3) {

package/Server/Utils/Monitor/Criteria/APIRequestCriteria.ts

@@ -70,7 +70,10 @@ export default class APIRequestCriteria {
     }
 
     //check response code
-    if (input.criteriaFilter.checkOn === CheckOn.ResponseStatusCode) {
+    if (
+      input.criteriaFilter.checkOn === CheckOn.ResponseStatusCode &&
+      (input.dataToProcess as ProbeMonitorResponse).responseCode
+    ) {
       threshold = CompareCriteria.convertToNumber(threshold);
 
       const value: Array<number> | number =

package/Server/Utils/Monitor/Criteria/CompareCriteria.ts

@@ -313,7 +313,8 @@ export default class CompareCriteria {
         CompareCriteria.isTrue({
           value: data.value,
           evaluationType:
-            data.criteriaFilter.evaluateOverTimeOptions?.evaluateOverTimeType,
+            data.criteriaFilter.evaluateOverTimeOptions?.evaluateOverTimeType ||
+            data.criteriaFilter.metricMonitorOptions?.metricAggregationType,
         })
       ) {
         return CompareCriteria.getCompareMessage({
@@ -331,7 +332,8 @@ export default class CompareCriteria {
         CompareCriteria.isFalse({
           value: data.value,
           evaluationType:
-            data.criteriaFilter.evaluateOverTimeOptions?.evaluateOverTimeType,
+            data.criteriaFilter.evaluateOverTimeOptions?.evaluateOverTimeType ||
+            data.criteriaFilter.metricMonitorOptions?.metricAggregationType,
         })
       ) {
         return CompareCriteria.getCompareMessage({
@@ -366,7 +368,8 @@ export default class CompareCriteria {
           threshold: data.threshold as number,
           value: data.value,
           evaluationType:
-            data.criteriaFilter.evaluateOverTimeOptions?.evaluateOverTimeType,
+            data.criteriaFilter.evaluateOverTimeOptions?.evaluateOverTimeType ||
+            data.criteriaFilter.metricMonitorOptions?.metricAggregationType,
         })
       ) {
         return CompareCriteria.getCompareMessage({
@@ -385,7 +388,8 @@ export default class CompareCriteria {
           threshold: data.threshold as number,
           value: data.value,
           evaluationType:
-            data.criteriaFilter.evaluateOverTimeOptions?.evaluateOverTimeType,
+            data.criteriaFilter.evaluateOverTimeOptions?.evaluateOverTimeType ||
+            data.criteriaFilter.metricMonitorOptions?.metricAggregationType,
         })
       ) {
         return CompareCriteria.getCompareMessage({
@@ -404,7 +408,8 @@ export default class CompareCriteria {
           threshold: data.threshold as number,
           value: data.value,
           evaluationType:
-            data.criteriaFilter.evaluateOverTimeOptions?.evaluateOverTimeType,
+            data.criteriaFilter.evaluateOverTimeOptions?.evaluateOverTimeType ||
+            data.criteriaFilter.metricMonitorOptions?.metricAggregationType,
         })
       ) {
         return CompareCriteria.getCompareMessage({
@@ -423,7 +428,8 @@ export default class CompareCriteria {
           threshold: data.threshold as number,
           value: data.value,
           evaluationType:
-            data.criteriaFilter.evaluateOverTimeOptions?.evaluateOverTimeType,
+            data.criteriaFilter.evaluateOverTimeOptions?.evaluateOverTimeType ||
+            data.criteriaFilter.metricMonitorOptions?.metricAggregationType,
         })
       ) {
         return CompareCriteria.getCompareMessage({
@@ -442,7 +448,8 @@ export default class CompareCriteria {
           threshold: data.threshold as number,
           value: data.value,
           evaluationType:
-            data.criteriaFilter.evaluateOverTimeOptions?.evaluateOverTimeType,
+            data.criteriaFilter.evaluateOverTimeOptions?.evaluateOverTimeType ||
+            data.criteriaFilter.metricMonitorOptions?.metricAggregationType,
         })
       ) {
         return CompareCriteria.getCompareMessage({
@@ -461,7 +468,8 @@ export default class CompareCriteria {
           threshold: data.threshold as number,
           value: data.value,
           evaluationType:
-            data.criteriaFilter.evaluateOverTimeOptions?.evaluateOverTimeType,
+            data.criteriaFilter.evaluateOverTimeOptions?.evaluateOverTimeType ||
+            data.criteriaFilter.metricMonitorOptions?.metricAggregationType,
         })
       ) {
         return CompareCriteria.getCompareMessage({
@@ -485,17 +493,19 @@ export default class CompareCriteria {
     // CPU Percent over the last 5 minutes is 10 which is less than the threshold of 20
     let message: string = "";
 
-    if (
-      data.criteriaFilter.evaluateOverTimeOptions?.evaluateOverTimeType ===
-      EvaluateOverTimeType.AnyValue
-    ) {
+    let evaluationType: EvaluateOverTimeType | undefined =
+      data.criteriaFilter.evaluateOverTimeOptions?.evaluateOverTimeType;
+
+    if (data.criteriaFilter.metricMonitorOptions?.metricAggregationType) {
+      evaluationType =
+        data.criteriaFilter.metricMonitorOptions.metricAggregationType;
+    }
+
+    if (evaluationType === EvaluateOverTimeType.AnyValue) {
       message += "Any value of";
     }
 
-    if (
-      data.criteriaFilter.evaluateOverTimeOptions?.evaluateOverTimeType ===
-      EvaluateOverTimeType.AllValues
-    ) {
+    if (evaluationType === EvaluateOverTimeType.AllValues) {
       message += "All values of";
     }
 

package/Server/Utils/Monitor/Criteria/MetricMonitorCriteria.ts

@@ -0,0 +1,127 @@
+import AggregateModel from "../../../../Types/BaseDatabase/AggregatedModel";
+import AggregatedResult from "../../../../Types/BaseDatabase/AggregatedResult";
+import MetricFormulaConfigData from "../../../../Types/Metrics/MetricFormulaConfigData";
+import MetricQueryConfigData from "../../../../Types/Metrics/MetricQueryConfigData";
+import MetricMonitorResponse from "../../../../Types/Monitor/MetricMonitor/MetricMonitorResponse";
+import MonitorStep from "../../../../Types/Monitor/MonitorStep";
+import DataToProcess from "../DataToProcess";
+import CompareCriteria from "./CompareCriteria";
+import {
+  CheckOn,
+  CriteriaFilter,
+  EvaluateOverTimeType,
+} from "Common/Types/Monitor/CriteriaFilter";
+
+export default class MetricMonitorCriteria {
+  public static async isMonitorInstanceCriteriaFilterMet(input: {
+    dataToProcess: DataToProcess;
+    criteriaFilter: CriteriaFilter;
+    monitorStep: MonitorStep;
+  }): Promise<string | null> {
+    // Metric Monitoring Check
+
+    if (
+      input.criteriaFilter.metricMonitorOptions &&
+      !input.criteriaFilter.metricMonitorOptions.metricAggregationType
+    ) {
+      input.criteriaFilter.metricMonitorOptions.metricAggregationType =
+        EvaluateOverTimeType.AnyValue;
+    }
+
+    let threshold: number | string | undefined | null =
+      input.criteriaFilter.value;
+
+    if (input.criteriaFilter.checkOn === CheckOn.MetricValue) {
+      threshold = CompareCriteria.convertToNumber(threshold);
+
+      const metricAggregaredResult: Array<AggregatedResult> =
+        (input.dataToProcess as MetricMonitorResponse).metricResult || [];
+
+      const metricAlias: string =
+        input.criteriaFilter.metricMonitorOptions?.metricAlias || "";
+
+      // Pick based on the alias, or if there's no alias, pick the first one
+
+      let aliasIndex: number =
+        input.monitorStep.data?.metricMonitor?.metricViewConfig?.queryConfigs.findIndex(
+          (queryConfig: MetricQueryConfigData) => {
+            return queryConfig.metricAliasData?.metricVariable === metricAlias;
+          },
+        ) || -1;
+
+      if (aliasIndex < 0) {
+        // then try to find in formula
+        let formulaIndex: number =
+          input.monitorStep.data?.metricMonitor?.metricViewConfig?.formulaConfigs.findIndex(
+            (formulaConfig: MetricFormulaConfigData) => {
+              return (
+                formulaConfig.metricAliasData?.metricVariable === metricAlias
+              );
+            },
+          ) || -1;
+
+        if (formulaIndex >= 0) {
+          // add number of queries to the index
+          formulaIndex =
+            formulaIndex +
+            (input.monitorStep.data?.metricMonitor?.metricViewConfig
+              ?.queryConfigs.length || 0);
+          aliasIndex = formulaIndex;
+        }
+      }
+      const aggregatedResult: AggregatedResult | undefined =
+        metricAggregaredResult &&
+        metricAggregaredResult.length >= aliasIndex - 1 &&
+        aliasIndex >= 0
+          ? metricAggregaredResult[aliasIndex]
+          : metricAggregaredResult[0] || undefined;
+
+      if (metricAlias) {
+        // find the index of the alias in the dataToProcess.
+        const indexOfAlias: number = (
+          input.dataToProcess as MetricMonitorResponse
+        ).metricViewConfig.queryConfigs.findIndex(
+          (queryConfig: MetricQueryConfigData) => {
+            return queryConfig.metricAliasData?.metricVariable === metricAlias;
+          },
+        );
+
+        // now get the aggregated result for that alias
+        if (indexOfAlias !== -1) {
+          const aggregatedResultForAlias: AggregatedResult | undefined =
+            metricAggregaredResult[indexOfAlias];
+          if (aggregatedResultForAlias) {
+            const numbers: Array<number> = aggregatedResultForAlias.data.map(
+              (data: AggregateModel) => {
+                return data.value;
+              },
+            );
+
+            return CompareCriteria.compareCriteriaNumbers({
+              value: numbers && numbers.length > 0 ? numbers : 0,
+              threshold: threshold as number,
+              criteriaFilter: input.criteriaFilter,
+            });
+          }
+        }
+      }
+
+      // if there's no alias then this is the default case
+      if (aggregatedResult) {
+        const numbers: Array<number> = aggregatedResult.data.map(
+          (data: AggregateModel) => {
+            return data.value;
+          },
+        );
+
+        return CompareCriteria.compareCriteriaNumbers({
+          value: numbers && numbers.length > 0 ? numbers : 0,
+          threshold: threshold as number,
+          criteriaFilter: input.criteriaFilter,
+        });
+      }
+    }
+
+    return null;
+  }
+}

package/Server/Utils/Monitor/DataToProcess.ts

@@ -3,12 +3,14 @@ import ServerMonitorResponse from "Common/Types/Monitor/ServerMonitor/ServerMoni
 import ProbeMonitorResponse from "Common/Types/Probe/ProbeMonitorResponse";
 import LogMonitorResponse from "Common/Types/Monitor/LogMonitor/LogMonitorResponse";
 import TraceMonitorResponse from "Common/Types/Monitor/TraceMonitor/TraceMonitorResponse";
+import MetricMonitorResponse from "../../../Types/Monitor/MetricMonitor/MetricMonitorResponse";
 
 type DataToProcess =
   | ProbeMonitorResponse
   | IncomingMonitorRequest
   | ServerMonitorResponse
   | LogMonitorResponse
-  | TraceMonitorResponse;
+  | TraceMonitorResponse
+  | MetricMonitorResponse;
 
 export default DataToProcess;

package/Server/Utils/Monitor/MonitorAlert.ts

@@ -12,6 +12,7 @@ import MonitorCriteriaInstance from "../../../Types/Monitor/MonitorCriteriaInsta
 import ObjectID from "../../../Types/ObjectID";
 import ProbeMonitorResponse from "../../../Types/Probe/ProbeMonitorResponse";
 import { TelemetryQuery } from "../../../Types/Telemetry/TelemetryQuery";
+import { DisableAutomaticAlertCreation } from "../../EnvironmentConfig";
 import AlertService from "../../Services/AlertService";
 import AlertSeverityService from "../../Services/AlertSeverityService";
 import AlertStateTimelineService from "../../Services/AlertStateTimelineService";
@@ -193,6 +194,10 @@ export default class MonitorAlert {
           alert.remediationNotes = criteriaAlert.remediationNotes;
         }
 
+        if (DisableAutomaticAlertCreation) {
+          return;
+        }
+
         await AlertService.create({
           data: alert,
           props: {

package/Server/Utils/Monitor/MonitorIncident.ts

@@ -12,6 +12,7 @@ import MonitorCriteriaInstance from "../../../Types/Monitor/MonitorCriteriaInsta
 import ObjectID from "../../../Types/ObjectID";
 import ProbeMonitorResponse from "../../../Types/Probe/ProbeMonitorResponse";
 import { TelemetryQuery } from "../../../Types/Telemetry/TelemetryQuery";
+import { DisableAutomaticIncidentCreation } from "../../EnvironmentConfig";
 import IncidentService from "../../Services/IncidentService";
 import IncidentSeverityService from "../../Services/IncidentSeverityService";
 import IncidentStateTimelineService from "../../Services/IncidentStateTimelineService";
@@ -203,6 +204,10 @@ export default class MonitorIncident {
           incident.remediationNotes = criteriaIncident.remediationNotes;
         }
 
+        if (DisableAutomaticIncidentCreation) {
+          return;
+        }
+
         await IncidentService.create({
           data: incident,
           props: {

package/Server/Utils/Monitor/MonitorResource.ts

@@ -55,6 +55,8 @@ import Metric, {
 import MetricService from "../../Services/MetricService";
 import MonitorMetricType from "../../../Types/Monitor/MonitorMetricType";
 import TelemetryUtil from "../Telemetry/Telemetry";
+import MetricMonitorCriteria from "./Criteria/MetricMonitorCriteria";
+import MetricMonitorResponse from "../../../Types/Monitor/MetricMonitor/MetricMonitorResponse";
 
 export default class MonitorResourceUtil {
   public static async monitorResource(
@@ -441,6 +443,7 @@ export default class MonitorResourceUtil {
         telemetryQuery = {
           telemetryQuery: (dataToProcess as LogMonitorResponse).logQuery,
           telemetryType: TelemetryType.Log,
+          metricViewData: null,
         };
         logger.debug(
           `${dataToProcess.monitorId.toString()} - Log query found.`,
@@ -451,6 +454,29 @@ export default class MonitorResourceUtil {
         telemetryQuery = {
           telemetryQuery: (dataToProcess as TraceMonitorResponse).spanQuery,
           telemetryType: TelemetryType.Trace,
+          metricViewData: null,
+        };
+        logger.debug(
+          `${dataToProcess.monitorId.toString()} - Span query found.`,
+        );
+      }
+
+      if (
+        dataToProcess &&
+        (dataToProcess as MetricMonitorResponse).metricViewConfig &&
+        (dataToProcess as MetricMonitorResponse).startAndEndDate
+      ) {
+        telemetryQuery = {
+          telemetryQuery: null,
+          telemetryType: TelemetryType.Metric,
+          metricViewData: {
+            startAndEndDate:
+              (dataToProcess as MetricMonitorResponse).startAndEndDate || null,
+            queryConfigs: (dataToProcess as MetricMonitorResponse)
+              .metricViewConfig.queryConfigs,
+            formulaConfigs: (dataToProcess as MetricMonitorResponse)
+              .metricViewConfig.formulaConfigs,
+          },
         };
         logger.debug(
           `${dataToProcess.monitorId.toString()} - Span query found.`,
@@ -1273,6 +1299,20 @@ export default class MonitorResourceUtil {
       }
     }
 
+    if (input.monitor.monitorType === MonitorType.Metrics) {
+      // check server monitor
+      const logMonitorResult: string | null =
+        await MetricMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess: input.dataToProcess,
+          criteriaFilter: input.criteriaFilter,
+          monitorStep: input.monitorStep,
+        });
+
+      if (logMonitorResult) {
+        return logMonitorResult;
+      }
+    }
+
     if (input.monitor.monitorType === MonitorType.Traces) {
       // check server monitor
       const traceMonitorResult: string | null =

package/Server/Utils/Stream.ts

@@ -11,6 +11,10 @@ export default class StreamUtil {
         const chunks: Array<any> = [];
 
         stream.on("data", (chunk: any) => {
+          if (Array.isArray(chunk) && chunk.length === 0) {
+            return;
+          }
+
           chunks.push(Buffer.from(chunk));
         });
         stream.on("end", () => {

package/Types/Date.ts

@@ -9,6 +9,15 @@ import Timezone from "./Timezone";
 export const Moment: typeof moment = moment;
 
 export default class OneUptimeDate {
+  public static getInBetweenDatesAsFormattedString(
+    inBetween: InBetween<Date>,
+  ): string {
+    return (
+      this.getDateAsFormattedString(inBetween.startValue) +
+      " - " +
+      this.getDateAsFormattedString(inBetween.endValue)
+    );
+  }
   public static convertMinutesToMilliseconds(minutes: number): number {
     return minutes * 60 * 1000;
   }

package/Types/Metrics/MetricViewData.ts

@@ -0,0 +1,6 @@
+import InBetween from "Common/Types/BaseDatabase/InBetween";
+import MetricsViewConfig from "Common/Types/Metrics/MetricsViewConfig";
+
+export default interface MetricViewData extends MetricsViewConfig {
+  startAndEndDate: InBetween<Date> | null;
+}

package/Types/Monitor/CriteriaFilter.ts

@@ -38,6 +38,9 @@ export enum CheckOn {
 
   // Trace monitors.
   SpanCount = "Span Count",
+
+  // Metric Monitors.
+  MetricValue = "Metric Value",
 }
 
 export interface ServerMonitorOptions {
@@ -53,6 +56,11 @@ export enum EvaluateOverTimeType {
   AnyValue = "Any Value",
 }
 
+export interface MetricMonitorOptions {
+  metricAlias?: string | undefined;
+  metricAggregationType?: EvaluateOverTimeType | undefined;
+}
+
 export enum EvaluateOverTimeMinutes {
   TwoMinutes = "2",
   ThreeMinutes = "3",
@@ -73,6 +81,7 @@ export interface EvaluateOverTimeOptions {
 export interface CriteriaFilter {
   checkOn: CheckOn;
   serverMonitorOptions?: ServerMonitorOptions | undefined;
+  metricMonitorOptions?: MetricMonitorOptions | undefined;
   filterType: FilterType | undefined;
   value: string | number | undefined;
   eveluateOverTime?: boolean | undefined;

package/Types/Monitor/MetricMonitor/MetricMonitorResponse.ts

@@ -0,0 +1,11 @@
+import AggregatedResult from "../../BaseDatabase/AggregatedResult";
+import InBetween from "../../BaseDatabase/InBetween";
+import MetricsViewConfig from "../../Metrics/MetricsViewConfig";
+import ObjectID from "../../ObjectID";
+
+export default interface MetricMonitorResponse {
+  startAndEndDate?: InBetween<Date>;
+  metricResult: Array<AggregatedResult>;
+  metricViewConfig: MetricsViewConfig;
+  monitorId: ObjectID;
+}

package/Types/Monitor/MonitorCriteriaInstance.ts

@@ -10,6 +10,7 @@ import {
   CriteriaFilter,
   FilterCondition,
   FilterType,
+  EvaluateOverTimeType,
 } from "./CriteriaFilter";
 import { CriteriaIncident } from "./CriteriaIncident";
 import MonitorType from "./MonitorType";
@@ -59,6 +60,9 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
     monitorType: MonitorType;
     monitorStatusId: ObjectID;
     monitorName: string;
+    metricOptions?: {
+      metricAliases: Array<string>;
+    };
   }): MonitorCriteriaInstance | null {
     if (arg.monitorType === MonitorType.IncomingRequest) {
       const monitorCriteriaInstance: MonitorCriteriaInstance =
@@ -114,6 +118,43 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
       return monitorCriteriaInstance;
     }
 
+    if (arg.monitorType === MonitorType.Metrics) {
+      const monitorCriteriaInstance: MonitorCriteriaInstance =
+        new MonitorCriteriaInstance();
+
+      monitorCriteriaInstance.data = {
+        id: ObjectID.generate().toString(),
+        monitorStatusId: arg.monitorStatusId,
+        filterCondition: FilterCondition.Any,
+        filters: [
+          {
+            checkOn: CheckOn.MetricValue,
+            filterType: FilterType.GreaterThan,
+
+            metricMonitorOptions: {
+              metricAggregationType: EvaluateOverTimeType.AnyValue,
+              metricAlias:
+                arg.metricOptions &&
+                arg.metricOptions.metricAliases &&
+                arg.metricOptions.metricAliases.length > 0
+                  ? arg.metricOptions.metricAliases[0]
+                  : undefined,
+            },
+            value: 0, // if there are some logs then monitor is online.
+          },
+        ],
+        incidents: [],
+        alerts: [],
+        changeMonitorStatus: true,
+        createIncidents: false,
+        createAlerts: false,
+        name: `Check if ${arg.monitorName} is online`,
+        description: `This criteria checks if the ${arg.monitorName} is online`,
+      };
+
+      return monitorCriteriaInstance;
+    }
+
     if (arg.monitorType === MonitorType.Traces) {
       const monitorCriteriaInstance: MonitorCriteriaInstance =
         new MonitorCriteriaInstance();
@@ -278,6 +319,9 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
     incidentSeverityId: ObjectID;
     alertSeverityId: ObjectID;
     monitorName: string;
+    metricOptions?: {
+      metricAliases: Array<string>;
+    };
   }): MonitorCriteriaInstance {
     const monitorCriteriaInstance: MonitorCriteriaInstance =
       new MonitorCriteriaInstance();
@@ -415,6 +459,55 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
       };
     }
 
+    if (arg.monitorType === MonitorType.Metrics) {
+      monitorCriteriaInstance.data = {
+        id: ObjectID.generate().toString(),
+        monitorStatusId: arg.monitorStatusId,
+        filterCondition: FilterCondition.Any,
+        filters: [
+          {
+            checkOn: CheckOn.MetricValue,
+            filterType: FilterType.EqualTo,
+            metricMonitorOptions: {
+              metricAggregationType: EvaluateOverTimeType.AnyValue,
+              metricAlias:
+                arg.metricOptions &&
+                arg.metricOptions.metricAliases &&
+                arg.metricOptions.metricAliases.length > 0
+                  ? arg.metricOptions.metricAliases[0]
+                  : undefined,
+            },
+            value: 0, // if there are no logs then the monitor is offline
+          },
+        ],
+        incidents: [
+          {
+            title: `${arg.monitorName} is offline`,
+            description: `${arg.monitorName} is currently offline.`,
+            incidentSeverityId: arg.incidentSeverityId,
+            autoResolveIncident: true,
+            id: ObjectID.generate().toString(),
+            onCallPolicyIds: [],
+          },
+        ],
+        alerts: [
+          {
+            title: `${arg.monitorName} is offline`,
+            description: `${arg.monitorName} is currently offline.`,
+            alertSeverityId: arg.alertSeverityId,
+            autoResolveAlert: true,
+            id: ObjectID.generate().toString(),
+            onCallPolicyIds: [],
+          },
+        ],
+        createAlerts: false,
+        changeMonitorStatus: true,
+        createIncidents: true,
+        name: `Check if ${arg.monitorName} is offline`,
+        description: `This criteria checks if the ${arg.monitorName} is offline`,
+      };
+    }
+
     if (arg.monitorType === MonitorType.Traces) {
       monitorCriteriaInstance.data = {
         id: ObjectID.generate().toString(),