@oneuptime/common 7.0.3336 → 7.0.3341

package/Models/AnalyticsModels/Metric.ts

@@ -22,6 +22,8 @@ export enum MetricPointType {
 export enum ServiceType {
   OpenTelemetry = "OpenTelemetry",
   Monitor = "Monitor",
+  Alert = "Alert",
+  Incident = "Incident",
 }
 
 export default class Metric extends AnalyticsBaseModel {

package/Server/Services/AlertService.ts

@@ -28,6 +28,16 @@ import AlertState from "Common/Models/DatabaseModels/AlertState";
 import AlertStateTimeline from "Common/Models/DatabaseModels/AlertStateTimeline";
 import User from "Common/Models/DatabaseModels/User";
 import { IsBillingEnabled } from "../EnvironmentConfig";
+import TelemetryType from "../../Types/Telemetry/TelemetryType";
+import logger from "../Utils/Logger";
+import TelemetryUtil from "../Utils/Telemetry/Telemetry";
+import MetricService from "./MetricService";
+import OneUptimeDate from "../../Types/Date";
+import Metric, {
+  MetricPointType,
+  ServiceType,
+} from "../../Models/AnalyticsModels/Metric";
+import AlertMetricType from "../../Types/Alerts/AlertMetricType";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -564,5 +574,265 @@ export class Service extends DatabaseService<Model> {
       props: props || {},
     });
   }
+
+  public async refreshAlertMetrics(data: { alertId: ObjectID }): Promise<void> {
+    const alert: Model | null = await this.findOneById({
+      id: data.alertId,
+      select: {
+        projectId: true,
+        monitor: {
+          _id: true,
+          name: true,
+        },
+        alertSeverity: {
+          name: true,
+          _id: true,
+        },
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!alert) {
+      throw new BadDataException("Alert not found");
+    }
+
+    if (!alert.projectId) {
+      throw new BadDataException("Incient Project ID not found");
+    }
+
+    // get alert state timeline
+
+    const alertStateTimelines: Array<AlertStateTimeline> =
+      await AlertStateTimelineService.findBy({
+        query: {
+          alertId: data.alertId,
+        },
+        select: {
+          projectId: true,
+          alertStateId: true,
+          alertState: {
+            isAcknowledgedState: true,
+            isResolvedState: true,
+          },
+          startsAt: true,
+          endsAt: true,
+        },
+        sort: {
+          startsAt: SortOrder.Ascending,
+        },
+        skip: 0,
+        limit: LIMIT_PER_PROJECT,
+        props: {
+          isRoot: true,
+        },
+      });
+
+    const firstAlertStateTimeline: AlertStateTimeline | undefined =
+      alertStateTimelines[0];
+
+    // delete all the alert metrics with this alert id because its a refresh.
+
+    await MetricService.deleteBy({
+      query: {
+        serviceId: data.alertId,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    const itemsToSave: Array<Metric> = [];
+
+    // now we need to create new metrics for this alert - TimeToAcknowledge, TimeToResolve, AlertCount, AlertDuration
+
+    const alertStartsAt: Date =
+      firstAlertStateTimeline?.startsAt ||
+      alert.createdAt ||
+      OneUptimeDate.getCurrentDate();
+
+    const alertCountMetric: Metric = new Metric();
+
+    alertCountMetric.projectId = alert.projectId;
+    alertCountMetric.serviceId = alert.id!;
+    alertCountMetric.serviceType = ServiceType.Alert;
+    alertCountMetric.name = AlertMetricType.AlertCount;
+    alertCountMetric.description = "Number of alerts created";
+    alertCountMetric.value = 1;
+    alertCountMetric.unit = "";
+    alertCountMetric.attributes = {
+      alertId: data.alertId.toString(),
+      projectId: alert.projectId.toString(),
+      monitorId: alert.monitor?.id!.toString() || "",
+      monitorName: alert.monitor?.name!.toString() || "",
+      alertSeverityId: alert.alertSeverity?.id!.toString() || "",
+      alertSeverityName: alert.alertSeverity?.name!.toString() || "",
+    };
+
+    alertCountMetric.time = alertStartsAt;
+    alertCountMetric.timeUnixNano = OneUptimeDate.toUnixNano(
+      alertCountMetric.time,
+    );
+    alertCountMetric.metricPointType = MetricPointType.Sum;
+
+    itemsToSave.push(alertCountMetric);
+
+    // is the alert acknowledged?
+    const isAlertAcknowledged: boolean = alertStateTimelines.some(
+      (timeline: AlertStateTimeline) => {
+        return timeline.alertState?.isAcknowledgedState;
+      },
+    );
+
+    if (isAlertAcknowledged) {
+      const ackAlertStateTimeline: AlertStateTimeline | undefined =
+        alertStateTimelines.find((timeline: AlertStateTimeline) => {
+          return timeline.alertState?.isAcknowledgedState;
+        });
+
+      if (ackAlertStateTimeline) {
+        const timeToAcknowledgeMetric: Metric = new Metric();
+
+        timeToAcknowledgeMetric.projectId = alert.projectId;
+        timeToAcknowledgeMetric.serviceId = alert.id!;
+        timeToAcknowledgeMetric.serviceType = ServiceType.Alert;
+        timeToAcknowledgeMetric.name = AlertMetricType.TimeToAcknowledge;
+        timeToAcknowledgeMetric.description =
+          "Time taken to acknowledge the alert";
+        timeToAcknowledgeMetric.value = OneUptimeDate.getDifferenceInSeconds(
+          ackAlertStateTimeline?.startsAt || OneUptimeDate.getCurrentDate(),
+          alertStartsAt,
+        );
+        timeToAcknowledgeMetric.unit = "seconds";
+        timeToAcknowledgeMetric.attributes = {
+          alertId: data.alertId.toString(),
+          projectId: alert.projectId.toString(),
+          monitorId: alert.monitor?.id!.toString() || "",
+          monitorName: alert.monitor?.name!.toString() || "",
+          alertSeverityId: alert.alertSeverity?.id!.toString() || "",
+          alertSeverityName: alert.alertSeverity?.name!.toString() || "",
+        };
+
+        timeToAcknowledgeMetric.time =
+          ackAlertStateTimeline?.startsAt ||
+          alert.createdAt ||
+          OneUptimeDate.getCurrentDate();
+        timeToAcknowledgeMetric.timeUnixNano = OneUptimeDate.toUnixNano(
+          timeToAcknowledgeMetric.time,
+        );
+        timeToAcknowledgeMetric.metricPointType = MetricPointType.Sum;
+
+        itemsToSave.push(timeToAcknowledgeMetric);
+      }
+    }
+
+    // time to resolve
+    const isAlertResolved: boolean = alertStateTimelines.some(
+      (timeline: AlertStateTimeline) => {
+        return timeline.alertState?.isResolvedState;
+      },
+    );
+
+    if (isAlertResolved) {
+      const resolvedAlertStateTimeline: AlertStateTimeline | undefined =
+        alertStateTimelines.find((timeline: AlertStateTimeline) => {
+          return timeline.alertState?.isResolvedState;
+        });
+
+      if (resolvedAlertStateTimeline) {
+        const timeToResolveMetric: Metric = new Metric();
+
+        timeToResolveMetric.projectId = alert.projectId;
+        timeToResolveMetric.serviceId = alert.id!;
+        timeToResolveMetric.serviceType = ServiceType.Alert;
+        timeToResolveMetric.name = AlertMetricType.TimeToResolve;
+        timeToResolveMetric.description = "Time taken to resolve the alert";
+        timeToResolveMetric.value = OneUptimeDate.getDifferenceInSeconds(
+          resolvedAlertStateTimeline?.startsAt ||
+            OneUptimeDate.getCurrentDate(),
+          alertStartsAt,
+        );
+        timeToResolveMetric.unit = "seconds";
+        timeToResolveMetric.attributes = {
+          alertId: data.alertId.toString(),
+          projectId: alert.projectId.toString(),
+          monitorId: alert.monitor?.id!.toString() || "",
+          monitorName: alert.monitor?.name!.toString() || "",
+          alertSeverityId: alert.alertSeverity?.id!.toString() || "",
+          alertSeverityName: alert.alertSeverity?.name!.toString() || "",
+        };
+
+        timeToResolveMetric.time =
+          resolvedAlertStateTimeline?.startsAt ||
+          alert.createdAt ||
+          OneUptimeDate.getCurrentDate();
+        timeToResolveMetric.timeUnixNano = OneUptimeDate.toUnixNano(
+          timeToResolveMetric.time,
+        );
+        timeToResolveMetric.metricPointType = MetricPointType.Sum;
+
+        itemsToSave.push(timeToResolveMetric);
+      }
+    }
+
+    // alert duration
+
+    const alertDurationMetric: Metric = new Metric();
+
+    const lastAlertStateTimeline: AlertStateTimeline | undefined =
+      alertStateTimelines[alertStateTimelines.length - 1];
+
+    if (lastAlertStateTimeline) {
+      const alertEndsAt: Date =
+        lastAlertStateTimeline.startsAt || OneUptimeDate.getCurrentDate();
+
+      // save metric.
+
+      alertDurationMetric.projectId = alert.projectId;
+      alertDurationMetric.serviceId = alert.id!;
+      alertDurationMetric.serviceType = ServiceType.Alert;
+      alertDurationMetric.name = AlertMetricType.AlertDuration;
+      alertDurationMetric.description = "Duration of the alert";
+      alertDurationMetric.value = OneUptimeDate.getDifferenceInSeconds(
+        alertEndsAt,
+        alertStartsAt,
+      );
+      alertDurationMetric.unit = "seconds";
+      alertDurationMetric.attributes = {
+        alertId: data.alertId.toString(),
+        projectId: alert.projectId.toString(),
+        monitorId: alert.monitor?.id!.toString() || "",
+        monitorName: alert.monitor?.name!.toString() || "",
+        alertSeverityId: alert.alertSeverity?.id!.toString() || "",
+        alertSeverityName: alert.alertSeverity?.name!.toString() || "",
+      };
+
+      alertDurationMetric.time =
+        lastAlertStateTimeline?.startsAt ||
+        alert.createdAt ||
+        OneUptimeDate.getCurrentDate();
+      alertDurationMetric.timeUnixNano = OneUptimeDate.toUnixNano(
+        alertDurationMetric.time,
+      );
+      alertDurationMetric.metricPointType = MetricPointType.Sum;
+    }
+
+    await MetricService.createMany({
+      items: itemsToSave,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    // index attributes.
+    TelemetryUtil.indexAttributes({
+      attributes: ["monitorId", "projectId", "alertId", "monitorNames"],
+      projectId: alert.projectId,
+      telemetryType: TelemetryType.Metric,
+    }).catch((err: Error) => {
+      logger.error(err);
+    });
+  }
 }
 export default new Service();

package/Server/Services/AlertStateTimelineService.ts

@@ -18,6 +18,7 @@ import { IsBillingEnabled } from "../EnvironmentConfig";
 import { JSONObject } from "../../Types/JSON";
 import AlertInternalNote from "../../Models/DatabaseModels/AlertInternalNote";
 import AlertInternalNoteService from "./AlertInternalNoteService";
+import logger from "../Utils/Logger";
 
 export class Service extends DatabaseService<AlertStateTimeline> {
   public constructor() {
@@ -173,6 +174,15 @@ export class Service extends DatabaseService<AlertStateTimeline> {
       props: onCreate.createBy.props,
     });
 
+    AlertService.refreshAlertMetrics({
+      alertId: createdItem.alertId,
+    }).catch((error: Error) => {
+      logger.error(
+        "Error while refreshing alert metrics after alert state timeline creation",
+      );
+      logger.error(error);
+    });
+
     return createdItem;
   }
 

package/Server/Services/IncidentService.ts

@@ -34,6 +34,16 @@ import MonitorStatus from "Common/Models/DatabaseModels/MonitorStatus";
 import MonitorStatusTimeline from "Common/Models/DatabaseModels/MonitorStatusTimeline";
 import User from "Common/Models/DatabaseModels/User";
 import { IsBillingEnabled } from "../EnvironmentConfig";
+import MetricService from "./MetricService";
+import IncidentMetricType from "../../Types/Incident/IncidentMetricType";
+import Metric, {
+  MetricPointType,
+  ServiceType,
+} from "../../Models/AnalyticsModels/Metric";
+import OneUptimeDate from "../../Types/Date";
+import TelemetryUtil from "../Utils/Telemetry/Telemetry";
+import TelemetryType from "../../Types/Telemetry/TelemetryType";
+import logger from "../Utils/Logger";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -139,6 +149,8 @@ export class Service extends DatabaseService<Model> {
         isRoot: true,
       },
     });
+
+    // store incident metric
   }
 
   protected override async onBeforeCreate(
@@ -737,5 +749,291 @@ export class Service extends DatabaseService<Model> {
       props: props || {},
     });
   }
+
+  public async refreshIncidentMetrics(data: {
+    incidentId: ObjectID;
+  }): Promise<void> {
+    const incident: Model | null = await this.findOneById({
+      id: data.incidentId,
+      select: {
+        projectId: true,
+        monitors: {
+          _id: true,
+          name: true,
+        },
+        incidentSeverity: {
+          _id: true,
+          name: true,
+        },
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!incident) {
+      throw new BadDataException("Incident not found");
+    }
+
+    if (!incident.projectId) {
+      throw new BadDataException("Incient Project ID not found");
+    }
+
+    // get incident state timeline
+
+    const incidentStateTimelines: Array<IncidentStateTimeline> =
+      await IncidentStateTimelineService.findBy({
+        query: {
+          incidentId: data.incidentId,
+        },
+        select: {
+          projectId: true,
+          incidentStateId: true,
+          incidentState: {
+            isAcknowledgedState: true,
+            isResolvedState: true,
+          },
+          startsAt: true,
+          endsAt: true,
+        },
+        sort: {
+          startsAt: SortOrder.Ascending,
+        },
+        skip: 0,
+        limit: LIMIT_PER_PROJECT,
+        props: {
+          isRoot: true,
+        },
+      });
+
+    const firstIncidentStateTimeline: IncidentStateTimeline | undefined =
+      incidentStateTimelines[0];
+
+    // delete all the incident metrics with this incident id because its a refresh.
+
+    await MetricService.deleteBy({
+      query: {
+        serviceId: data.incidentId,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    const itemsToSave: Array<Metric> = [];
+
+    // now we need to create new metrics for this incident - TimeToAcknowledge, TimeToResolve, IncidentCount, IncidentDuration
+
+    const incidentStartsAt: Date =
+      firstIncidentStateTimeline?.startsAt ||
+      incident.createdAt ||
+      OneUptimeDate.getCurrentDate();
+
+    const incidentCountMetric: Metric = new Metric();
+
+    incidentCountMetric.projectId = incident.projectId;
+    incidentCountMetric.serviceId = incident.id!;
+    incidentCountMetric.serviceType = ServiceType.Incident;
+    incidentCountMetric.name = IncidentMetricType.IncidentCount;
+    incidentCountMetric.description = "Number of incidents created";
+    incidentCountMetric.value = 1;
+    incidentCountMetric.unit = "";
+    incidentCountMetric.attributes = {
+      incidentId: data.incidentId.toString(),
+      projectId: incident.projectId.toString(),
+      monitorIds:
+        incident.monitors?.map((monitor: Monitor) => {
+          return monitor._id?.toString();
+        }) || [],
+      monitorNames:
+        incident.monitors?.map((monitor: Monitor) => {
+          return monitor.name?.toString();
+        }) || [],
+      incidentSeverityId: incident.incidentSeverity?._id?.toString(),
+      incidentSeverityName: incident.incidentSeverity?.name?.toString(),
+    };
+
+    incidentCountMetric.time = incidentStartsAt;
+    incidentCountMetric.timeUnixNano = OneUptimeDate.toUnixNano(
+      incidentCountMetric.time,
+    );
+    incidentCountMetric.metricPointType = MetricPointType.Sum;
+
+    itemsToSave.push(incidentCountMetric);
+
+    // is the incident acknowledged?
+    const isIncidentAcknowledged: boolean = incidentStateTimelines.some(
+      (timeline: IncidentStateTimeline) => {
+        return timeline.incidentState?.isAcknowledgedState;
+      },
+    );
+
+    if (isIncidentAcknowledged) {
+      const ackIncidentStateTimeline: IncidentStateTimeline | undefined =
+        incidentStateTimelines.find((timeline: IncidentStateTimeline) => {
+          return timeline.incidentState?.isAcknowledgedState;
+        });
+
+      if (ackIncidentStateTimeline) {
+        const timeToAcknowledgeMetric: Metric = new Metric();
+
+        timeToAcknowledgeMetric.projectId = incident.projectId;
+        timeToAcknowledgeMetric.serviceId = incident.id!;
+        timeToAcknowledgeMetric.serviceType = ServiceType.Incident;
+        timeToAcknowledgeMetric.name = IncidentMetricType.TimeToAcknowledge;
+        timeToAcknowledgeMetric.description =
+          "Time taken to acknowledge the incident";
+        timeToAcknowledgeMetric.value = OneUptimeDate.getDifferenceInSeconds(
+          ackIncidentStateTimeline?.startsAt || OneUptimeDate.getCurrentDate(),
+          incidentStartsAt,
+        );
+        timeToAcknowledgeMetric.unit = "seconds";
+        timeToAcknowledgeMetric.attributes = {
+          incidentId: data.incidentId.toString(),
+          projectId: incident.projectId.toString(),
+          monitorIds:
+            incident.monitors?.map((monitor: Monitor) => {
+              return monitor._id?.toString();
+            }) || [],
+          monitorNames:
+            incident.monitors?.map((monitor: Monitor) => {
+              return monitor.name?.toString();
+            }) || [],
+          incidentSeverityId: incident.incidentSeverity?._id?.toString(),
+          incidentSeverityName: incident.incidentSeverity?.name?.toString(),
+        };
+
+        timeToAcknowledgeMetric.time =
+          ackIncidentStateTimeline?.startsAt ||
+          incident.createdAt ||
+          OneUptimeDate.getCurrentDate();
+        timeToAcknowledgeMetric.timeUnixNano = OneUptimeDate.toUnixNano(
+          timeToAcknowledgeMetric.time,
+        );
+        timeToAcknowledgeMetric.metricPointType = MetricPointType.Sum;
+
+        itemsToSave.push(timeToAcknowledgeMetric);
+      }
+    }
+
+    // time to resolve
+    const isIncidentResolved: boolean = incidentStateTimelines.some(
+      (timeline: IncidentStateTimeline) => {
+        return timeline.incidentState?.isResolvedState;
+      },
+    );
+
+    if (isIncidentResolved) {
+      const resolvedIncidentStateTimeline: IncidentStateTimeline | undefined =
+        incidentStateTimelines.find((timeline: IncidentStateTimeline) => {
+          return timeline.incidentState?.isResolvedState;
+        });
+
+      if (resolvedIncidentStateTimeline) {
+        const timeToResolveMetric: Metric = new Metric();
+
+        timeToResolveMetric.projectId = incident.projectId;
+        timeToResolveMetric.serviceId = incident.id!;
+        timeToResolveMetric.serviceType = ServiceType.Incident;
+        timeToResolveMetric.name = IncidentMetricType.TimeToResolve;
+        timeToResolveMetric.description = "Time taken to resolve the incident";
+        timeToResolveMetric.value = OneUptimeDate.getDifferenceInSeconds(
+          resolvedIncidentStateTimeline?.startsAt ||
+            OneUptimeDate.getCurrentDate(),
+          incidentStartsAt,
+        );
+        timeToResolveMetric.unit = "seconds";
+        timeToResolveMetric.attributes = {
+          incidentId: data.incidentId.toString(),
+          projectId: incident.projectId.toString(),
+          monitorIds:
+            incident.monitors?.map((monitor: Monitor) => {
+              return monitor._id?.toString();
+            }) || [],
+          monitorNames:
+            incident.monitors?.map((monitor: Monitor) => {
+              return monitor.name?.toString();
+            }) || [],
+          incidentSeverityId: incident.incidentSeverity?._id?.toString(),
+          incidentSeverityName: incident.incidentSeverity?.name?.toString(),
+        };
+
+        timeToResolveMetric.time =
+          resolvedIncidentStateTimeline?.startsAt ||
+          incident.createdAt ||
+          OneUptimeDate.getCurrentDate();
+        timeToResolveMetric.timeUnixNano = OneUptimeDate.toUnixNano(
+          timeToResolveMetric.time,
+        );
+        timeToResolveMetric.metricPointType = MetricPointType.Sum;
+
+        itemsToSave.push(timeToResolveMetric);
+      }
+    }
+
+    // incident duration
+
+    const incidentDurationMetric: Metric = new Metric();
+
+    const lastIncidentStateTimeline: IncidentStateTimeline | undefined =
+      incidentStateTimelines[incidentStateTimelines.length - 1];
+
+    if (lastIncidentStateTimeline) {
+      const incidentEndsAt: Date =
+        lastIncidentStateTimeline.startsAt || OneUptimeDate.getCurrentDate();
+
+      // save metric.
+
+      incidentDurationMetric.projectId = incident.projectId;
+      incidentDurationMetric.serviceId = incident.id!;
+      incidentDurationMetric.serviceType = ServiceType.Incident;
+      incidentDurationMetric.name = IncidentMetricType.IncidentDuration;
+      incidentDurationMetric.description = "Duration of the incident";
+      incidentDurationMetric.value = OneUptimeDate.getDifferenceInSeconds(
+        incidentEndsAt,
+        incidentStartsAt,
+      );
+      incidentDurationMetric.unit = "seconds";
+      incidentDurationMetric.attributes = {
+        incidentId: data.incidentId.toString(),
+        projectId: incident.projectId.toString(),
+        monitorIds:
+          incident.monitors?.map((monitor: Monitor) => {
+            return monitor._id?.toString();
+          }) || [],
+        monitorNames:
+          incident.monitors?.map((monitor: Monitor) => {
+            return monitor.name?.toString();
+          }) || [],
+        incidentSeverityId: incident.incidentSeverity?._id?.toString(),
+        incidentSeverityName: incident.incidentSeverity?.name?.toString(),
+      };
+
+      incidentDurationMetric.time =
+        lastIncidentStateTimeline?.startsAt ||
+        incident.createdAt ||
+        OneUptimeDate.getCurrentDate();
+      incidentDurationMetric.timeUnixNano = OneUptimeDate.toUnixNano(
+        incidentDurationMetric.time,
+      );
+      incidentDurationMetric.metricPointType = MetricPointType.Sum;
+    }
+
+    await MetricService.createMany({
+      items: itemsToSave,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    // index attributes.
+    TelemetryUtil.indexAttributes({
+      attributes: ["monitorIds", "projectId", "incidentId", "monitorNames"],
+      projectId: incident.projectId,
+      telemetryType: TelemetryType.Metric,
+    }).catch((err: Error) => {
+      logger.error(err);
+    });
+  }
 }
 export default new Service();

package/Server/Services/IncidentStateTimelineService.ts

@@ -19,6 +19,7 @@ import IncidentState from "Common/Models/DatabaseModels/IncidentState";
 import IncidentStateTimeline from "Common/Models/DatabaseModels/IncidentStateTimeline";
 import User from "Common/Models/DatabaseModels/User";
 import { IsBillingEnabled } from "../EnvironmentConfig";
+import logger from "../Utils/Logger";
 
 export class Service extends DatabaseService<IncidentStateTimeline> {
   public constructor() {
@@ -227,6 +228,13 @@ export class Service extends DatabaseService<IncidentStateTimeline> {
       }
     }
 
+    IncidentService.refreshIncidentMetrics({
+      incidentId: createdItem.incidentId,
+    }).catch((error: Error) => {
+      logger.error(`Error while refreshing incident metrics:`);
+      logger.error(error);
+    });
+
     return createdItem;
   }
 

package/Types/Alerts/AlertMetricType.ts

@@ -0,0 +1,8 @@
+enum AlertMetricType {
+  TimeToAcknowledge = "oneuptime.alert.time-to-acknowledge",
+  TimeToResolve = "oneuptime.alert.time-to-resolve",
+  AlertCount = "oneuptime.alert.count",
+  AlertDuration = "oneuptime.alert.duration",
+}
+
+export default AlertMetricType;

package/Types/Date.ts

@@ -845,6 +845,18 @@ export default class OneUptimeDate {
     return minutes;
   }
 
+  public static getDifferenceInSeconds(date: Date, date2: Date): number {
+    date = this.fromString(date);
+    date2 = this.fromString(date2);
+    const seconds: number = moment(date).diff(moment(date2), "seconds");
+
+    if (seconds < 0) {
+      return seconds * -1;
+    }
+
+    return seconds;
+  }
+
   public static getDifferenceInMonths(date: Date, date2: Date): number {
     date = this.fromString(date);
     date2 = this.fromString(date2);

package/Types/Incident/IncidentMetricType.ts

@@ -0,0 +1,8 @@
+enum IncidentMetricType {
+  TimeToAcknowledge = "oneuptime.incident.time-to-acknowledge",
+  TimeToResolve = "oneuptime.incident.time-to-resolve",
+  IncidentCount = "oneuptime.incident.count",
+  IncidentDuration = "oneuptime.incident.duration",
+}
+
+export default IncidentMetricType;