@oneuptime/common 7.0.3357 → 7.0.3377

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/MetricMonitorCriteria.ts

@@ -0,0 +1,81 @@
+import AggregateModel from "../../../../Types/BaseDatabase/AggregatedModel";
+import AggregatedResult from "../../../../Types/BaseDatabase/AggregatedResult";
+import MetricQueryConfigData from "../../../../Types/Metrics/MetricQueryConfigData";
+import MetricMonitorResponse from "../../../../Types/Monitor/MetricMonitor/MetricMonitorResponse";
+import DataToProcess from "../DataToProcess";
+import CompareCriteria from "./CompareCriteria";
+import { CheckOn, CriteriaFilter } from "Common/Types/Monitor/CriteriaFilter";
+
+export default class MetricMonitorCriteria {
+  public static async isMonitorInstanceCriteriaFilterMet(input: {
+    dataToProcess: DataToProcess;
+    criteriaFilter: CriteriaFilter;
+  }): Promise<string | null> {
+    // Metric Monitoring Checks
+
+    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 || "";
+
+      const aggregatedResult: AggregatedResult | undefined =
+        metricAggregaredResult && metricAggregaredResult.length > 0
+          ? 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,
+              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,
+          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/MonitorResource.ts

@@ -55,6 +55,7 @@ import Metric, {
 import MetricService from "../../Services/MetricService";
 import MonitorMetricType from "../../../Types/Monitor/MonitorMetricType";
 import TelemetryUtil from "../Telemetry/Telemetry";
+import MetricMonitorCriteria from "./Criteria/MetricMonitorCriteria";
 
 export default class MonitorResourceUtil {
   public static async monitorResource(
@@ -1273,6 +1274,19 @@ 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,
+        });
+
+      if (logMonitorResult) {
+        return logMonitorResult;
+      }
+    }
+
     if (input.monitor.monitorType === MonitorType.Traces) {
       // check server monitor
       const traceMonitorResult: string | null =

package/Types/Monitor/CriteriaFilter.ts

@@ -38,12 +38,19 @@ export enum CheckOn {
 
   // Trace monitors.
   SpanCount = "Span Count",
+
+  // Metric Monitors.
+  MetricValue = "Metric Value",
 }
 
 export interface ServerMonitorOptions {
   diskPath?: string | undefined;
 }
 
+export interface MetricMonitorOptions {
+  metricAlias?: string | undefined;
+}
+
 export enum EvaluateOverTimeType {
   Average = "Average",
   Sum = "Sum",
@@ -73,6 +80,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

@@ -59,6 +59,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 +117,41 @@ 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: {
+              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 +316,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 +456,54 @@ 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: {
+              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(),

package/Types/Monitor/MonitorStep.ts

@@ -20,6 +20,9 @@ import { FindOperator } from "typeorm";
 import MonitorStepTraceMonitor, {
   MonitorStepTraceMonitorUtil,
 } from "./MonitorStepTraceMonitor";
+import MonitorStepMetricMonitor, {
+  MonitorStepMetricMonitorUtil,
+} from "./MonitorStepMetricMonitor";
 
 export interface MonitorStepType {
   id: string;
@@ -50,6 +53,9 @@ export interface MonitorStepType {
 
   // trace monitor type.
   traceMonitor?: MonitorStepTraceMonitor | undefined;
+
+  // Metric Monitor
+  metricMonitor: MonitorStepMetricMonitor | undefined;
 }
 
 export default class MonitorStep extends DatabaseProperty {
@@ -72,6 +78,7 @@ export default class MonitorStep extends DatabaseProperty {
       browserTypes: undefined,
       logMonitor: undefined,
       traceMonitor: undefined,
+      metricMonitor: undefined,
     };
   }
 
@@ -99,6 +106,7 @@ export default class MonitorStep extends DatabaseProperty {
       browserTypes: undefined,
       logMonitor: undefined,
       traceMonitor: undefined,
+      metricMonitor: undefined,
     };
 
     return monitorStep;
@@ -165,6 +173,13 @@ export default class MonitorStep extends DatabaseProperty {
     return this;
   }
 
+  public setMetricMonitor(
+    metricMonitor: MonitorStepMetricMonitor,
+  ): MonitorStep {
+    this.data!.metricMonitor = metricMonitor;
+    return this;
+  }
+
   public setTraceMonitor(traceMonitor: MonitorStepTraceMonitor): MonitorStep {
     this.data!.traceMonitor = traceMonitor;
     return this;
@@ -285,6 +300,9 @@ export default class MonitorStep extends DatabaseProperty {
                 this.data.logMonitor || MonitorStepLogMonitorUtil.getDefault(),
               )
             : undefined,
+          metricMonitor: this.data.metricMonitor
+            ? MonitorStepMetricMonitorUtil.toJSON(this.data.metricMonitor)
+            : undefined,
           traceMonitor: this.data.traceMonitor
             ? MonitorStepTraceMonitorUtil.toJSON(
                 this.data.traceMonitor ||
@@ -383,6 +401,9 @@ export default class MonitorStep extends DatabaseProperty {
       logMonitor: json["logMonitor"]
         ? (json["logMonitor"] as JSONObject)
         : undefined,
+      metricMonitor: json["metricMonitor"]
+        ? (json["metricMonitor"] as JSONObject)
+        : undefined,
       traceMonitor: json["traceMonitor"]
         ? (json["traceMonitor"] as JSONObject)
         : undefined,
@@ -396,6 +417,11 @@ export default class MonitorStep extends DatabaseProperty {
       monitorStep.data.traceMonitor = MonitorStepTraceMonitorUtil.getDefault();
     }
 
+    if (monitorStep.data && !monitorStep.data?.metricMonitor) {
+      monitorStep.data.metricMonitor =
+        MonitorStepMetricMonitorUtil.getDefault();
+    }
+
     return monitorStep;
   }
 

package/Types/Monitor/MonitorStepMetricMonitor.ts

@@ -0,0 +1,28 @@
+import { JSONObject } from "../JSON";
+import MetricsViewConfig from "../Metrics/MetricsViewConfig";
+import RollingTime from "../RollingTime/RollingTime";
+
+export default interface MonitorStepMetricMonitor {
+  metricViewConfig: MetricsViewConfig;
+  rollingTime: RollingTime;
+}
+
+export class MonitorStepMetricMonitorUtil {
+  public static getDefault(): MonitorStepMetricMonitor {
+    return {
+      metricViewConfig: {
+        queryConfigs: [],
+        formulaConfigs: [],
+      },
+      rollingTime: RollingTime.Past1Minute,
+    };
+  }
+
+  public static fromJSON(json: JSONObject): MonitorStepMetricMonitor {
+    return json as any as MonitorStepMetricMonitor;
+  }
+
+  public static toJSON(monitor: MonitorStepMetricMonitor): JSONObject {
+    return monitor as any as JSONObject;
+  }
+}

package/Types/Monitor/MonitorType.ts

@@ -115,7 +115,6 @@ export class MonitorTypeHelper {
         description:
           "This monitor type lets you monitor traces from any source.",
       },
-      // ,
       // {
       //   monitorType: MonitorType.Metrics,
       //   title: "Metrics",
@@ -205,7 +204,7 @@ export class MonitorTypeHelper {
     return monitorType !== MonitorType.Manual;
   }
 
-  public static doesMonitorTypeHaveMetrics(monitorType: MonitorType): boolean {
+  public static doesMonitorTypeHaveGraphs(monitorType: MonitorType): boolean {
     if (
       monitorType === MonitorType.Website ||
       monitorType === MonitorType.API ||

package/Types/RollingTime/RollingTime.ts

@@ -0,0 +1,24 @@
+enum RollingTime {
+  Past1Minute = "Past 1 Minute",
+  Past5Minutes = "Past 5 Minutes",
+  Past10Minutes = "Past 10 Minutes",
+  Past15Minutes = "Past 15 Minutes",
+  Past30Minutes = "Past 30 Minutes",
+  Past1Hour = "Past 1 Hour",
+  Past2Hours = "Past 2 Hours",
+  Past3Hours = "Past 3 Hours",
+  Past6Hours = "Past 6 Hours",
+  Past12Hours = "Past 12 Hours",
+  Past1Hours = "Past 1 Day",
+  Past2Days = "Past 2 Days",
+  Past3Days = "Past 3 Days",
+  Past7Days = "Past 7 Days",
+  Past14Days = "Past 14 Days",
+  Past30Days = "Past 30 Days",
+  Past60Days = "Past 60 Days",
+  Past90Days = "Past 90 Days",
+  Past180Days = "Past 180 Days",
+  Past365Days = "Past 365 Days",
+}
+
+export default RollingTime;

package/Types/RollingTime/RollingTimeUtil.ts

@@ -0,0 +1,98 @@
+import InBetween from "../BaseDatabase/InBetween";
+import OneUptimeDate from "../Date";
+import RollingTime from "./RollingTime";
+
+export default class RollingTimeUtil {
+  public static getDefault(): RollingTime {
+    return RollingTime.Past1Minute;
+  }
+
+  public static convertToStartAndEndDate(
+    rollingTime: RollingTime,
+  ): InBetween<Date> {
+    const endDate: Date = OneUptimeDate.getCurrentDate();
+    let startDate: Date = OneUptimeDate.getCurrentDate();
+
+    if (rollingTime === RollingTime.Past1Minute) {
+      startDate = OneUptimeDate.addRemoveMinutes(endDate, -1);
+    }
+
+    if (rollingTime === RollingTime.Past5Minutes) {
+      startDate = OneUptimeDate.addRemoveMinutes(endDate, -5);
+    }
+
+    if (rollingTime === RollingTime.Past10Minutes) {
+      startDate = OneUptimeDate.addRemoveMinutes(endDate, -10);
+    }
+
+    if (rollingTime === RollingTime.Past15Minutes) {
+      startDate = OneUptimeDate.addRemoveMinutes(endDate, -15);
+    }
+
+    if (rollingTime === RollingTime.Past30Minutes) {
+      startDate = OneUptimeDate.addRemoveMinutes(endDate, -30);
+    }
+
+    if (rollingTime === RollingTime.Past1Hour) {
+      startDate = OneUptimeDate.addRemoveHours(endDate, -1);
+    }
+
+    if (rollingTime === RollingTime.Past2Hours) {
+      startDate = OneUptimeDate.addRemoveHours(endDate, -2);
+    }
+
+    if (rollingTime === RollingTime.Past3Hours) {
+      startDate = OneUptimeDate.addRemoveHours(endDate, -3);
+    }
+
+    if (rollingTime === RollingTime.Past6Hours) {
+      startDate = OneUptimeDate.addRemoveHours(endDate, -6);
+    }
+
+    if (rollingTime === RollingTime.Past12Hours) {
+      startDate = OneUptimeDate.addRemoveHours(endDate, -12);
+    }
+
+    if (rollingTime === RollingTime.Past1Hours) {
+      startDate = OneUptimeDate.addRemoveDays(endDate, -1);
+    }
+
+    if (rollingTime === RollingTime.Past2Days) {
+      startDate = OneUptimeDate.addRemoveDays(endDate, -2);
+    }
+
+    if (rollingTime === RollingTime.Past3Days) {
+      startDate = OneUptimeDate.addRemoveDays(endDate, -3);
+    }
+
+    if (rollingTime === RollingTime.Past7Days) {
+      startDate = OneUptimeDate.addRemoveDays(endDate, -7);
+    }
+
+    if (rollingTime === RollingTime.Past14Days) {
+      startDate = OneUptimeDate.addRemoveDays(endDate, -14);
+    }
+
+    if (rollingTime === RollingTime.Past30Days) {
+      startDate = OneUptimeDate.addRemoveDays(endDate, -30);
+    }
+
+    if (rollingTime === RollingTime.Past60Days) {
+      startDate = OneUptimeDate.addRemoveDays(endDate, -60);
+    }
+
+    if (rollingTime === RollingTime.Past90Days) {
+      startDate = OneUptimeDate.addRemoveDays(endDate, -90);
+    }
+
+    if (rollingTime === RollingTime.Past180Days) {
+      startDate = OneUptimeDate.addRemoveDays(endDate, -180);
+    }
+
+    if (rollingTime === RollingTime.Past365Days) {
+      startDate = OneUptimeDate.addRemoveDays(endDate, -365);
+    }
+
+    return new InBetween(startDate, endDate);
+  }
+}

package/UI/Components/Charts/ChartGroup/ChartGroup.tsx

@@ -20,6 +20,7 @@ export interface ComponentProps {
   charts: Array<Chart>;
   hideCard?: boolean | undefined;
   heightInPx?: number | undefined;
+  chartCssClass?: string | undefined;
 }
 
 const ChartGroup: FunctionComponent<ComponentProps> = (
@@ -35,7 +36,7 @@ const ChartGroup: FunctionComponent<ComponentProps> = (
             return (
               <div
                 key={index}
-                className={`p-6 ${props.hideCard ? "" : "rounded-md bg-white shadow"}`}
+                className={`p-6 ${props.hideCard ? "" : "rounded-md bg-white shadow"} ${props.chartCssClass || ""}`}
               >
                 <h2
                   data-testid="card-details-heading"