@oneuptime/common 7.0.2936 → 7.0.2972

package/build/dist/Server/Utils/Monitor/MonitorResource.js

@@ -0,0 +1,833 @@
+import IncidentService from "../../Services/IncidentService";
+import IncidentSeverityService from "../../Services/IncidentSeverityService";
+import IncidentStateTimelineService from "../../Services/IncidentStateTimelineService";
+import MonitorMetricsByMinuteService from "../../Services/MonitorMetricsByMinuteService";
+import MonitorProbeService from "../../Services/MonitorProbeService";
+import MonitorService from "../../Services/MonitorService";
+import MonitorStatusTimelineService from "../../Services/MonitorStatusTimelineService";
+import logger from "../Logger";
+import VMUtil from "../VM/VMAPI";
+import APIRequestCriteria from "./Criteria/APIRequestCriteria";
+import CustomCodeMonitoringCriteria from "./Criteria/CustomCodeMonitorCriteria";
+import IncomingRequestCriteria from "./Criteria/IncomingRequestCriteria";
+import SSLMonitorCriteria from "./Criteria/SSLMonitorCriteria";
+import ServerMonitorCriteria from "./Criteria/ServerMonitorCriteria";
+import SyntheticMonitoringCriteria from "./Criteria/SyntheticMonitor";
+import SortOrder from "Common/Types/BaseDatabase/SortOrder";
+import { LIMIT_PER_PROJECT } from "Common/Types/Database/LimitMax";
+import BadDataException from "Common/Types/Exception/BadDataException";
+import { CheckOn, FilterCondition, } from "Common/Types/Monitor/CriteriaFilter";
+import MonitorType, { MonitorTypeHelper, } from "Common/Types/Monitor/MonitorType";
+import Typeof from "Common/Types/Typeof";
+import MonitorMetricsByMinute from "Common/Models/AnalyticsModels/MonitorMetricsByMinute";
+import Incident from "Common/Models/DatabaseModels/Incident";
+import IncidentStateTimeline from "Common/Models/DatabaseModels/IncidentStateTimeline";
+import MonitorStatusTimeline from "Common/Models/DatabaseModels/MonitorStatusTimeline";
+import OnCallDutyPolicy from "Common/Models/DatabaseModels/OnCallDutyPolicy";
+import OneUptimeDate from "Common/Types/Date";
+import LogMonitorCriteria from "./Criteria/LogMonitorCriteria";
+import TelemetryType from "Common/Types/Telemetry/TelemetryType";
+import TraceMonitorCriteria from "./Criteria/TraceMonitorCriteria";
+export default class MonitorResourceUtil {
+    static async monitorResource(dataToProcess) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        let response = {
+            monitorId: dataToProcess.monitorId,
+            criteriaMetId: undefined,
+            rootCause: null,
+        };
+        logger.debug("Processing probe response");
+        logger.debug("Monitor ID: " + dataToProcess.monitorId);
+        // fetch monitor
+        const monitor = await MonitorService.findOneById({
+            id: dataToProcess.monitorId,
+            select: {
+                monitorSteps: true,
+                monitorType: true,
+                projectId: true,
+                disableActiveMonitoring: true,
+                disableActiveMonitoringBecauseOfManualIncident: true,
+                disableActiveMonitoringBecauseOfScheduledMaintenanceEvent: true,
+                currentMonitorStatusId: true,
+                _id: true,
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+        if (!monitor) {
+            throw new BadDataException("Monitor not found");
+        }
+        if (monitor.disableActiveMonitoring) {
+            logger.debug(`${dataToProcess.monitorId.toString()} Monitor is disabled. Please enable it to start monitoring again.`);
+            throw new BadDataException("Monitor is disabled. Please enable it to start monitoring again.");
+        }
+        if (monitor.disableActiveMonitoringBecauseOfManualIncident) {
+            logger.debug(`${dataToProcess.monitorId.toString()} Monitor is disabled because an incident which is created manually is not resolved. Please resolve the incident to start monitoring again.`);
+            throw new BadDataException("Monitor is disabled because an incident which is created manually is not resolved. Please resolve the incident to start monitoring again.");
+        }
+        if (monitor.disableActiveMonitoringBecauseOfScheduledMaintenanceEvent) {
+            logger.debug(`${dataToProcess.monitorId.toString()} Monitor is disabled because one of the scheduled maintenance event this monitor is attached to has not ended. Please end the scheduled maintenance event to start monitoring again.`);
+            throw new BadDataException("Monitor is disabled because one of the scheduled maintenance event this monitor is attached to has not ended. Please end the scheduled maintenance event to start monitoring again.");
+        }
+        // save the last log to MonitorProbe.
+        // get last log. We do this because there are many monitoring steps and we need to store those.
+        logger.debug(`${dataToProcess.monitorId.toString()} - monitor type ${monitor.monitorType}`);
+        if (monitor.monitorType &&
+            MonitorTypeHelper.isProbableMonitor(monitor.monitorType)) {
+            dataToProcess = dataToProcess;
+            if (dataToProcess.probeId) {
+                const monitorProbe = await MonitorProbeService.findOneBy({
+                    query: {
+                        monitorId: monitor.id,
+                        probeId: dataToProcess.probeId,
+                    },
+                    select: {
+                        lastMonitoringLog: true,
+                    },
+                    props: {
+                        isRoot: true,
+                    },
+                });
+                if (!monitorProbe) {
+                    throw new BadDataException("Probe is not assigned to this monitor");
+                }
+                await MonitorProbeService.updateOneBy({
+                    query: {
+                        monitorId: monitor.id,
+                        probeId: dataToProcess.probeId,
+                    },
+                    data: {
+                        lastMonitoringLog: Object.assign(Object.assign({}, (monitorProbe.lastMonitoringLog || {})), { [dataToProcess.monitorStepId.toString()]: Object.assign(Object.assign({}, JSON.parse(JSON.stringify(dataToProcess))), { monitoredAt: OneUptimeDate.getCurrentDate() }) }),
+                    },
+                    props: {
+                        isRoot: true,
+                    },
+                });
+            }
+        }
+        if (monitor.monitorType === MonitorType.IncomingRequest &&
+            dataToProcess.incomingRequestReceivedAt) {
+            logger.debug(`${dataToProcess.monitorId.toString()} - Incoming request received at ${dataToProcess.incomingRequestReceivedAt}`);
+            await MonitorService.updateOneById({
+                id: monitor.id,
+                data: {
+                    incomingMonitorRequest: dataToProcess,
+                    incomingRequestReceivedAt: dataToProcess
+                        .incomingRequestReceivedAt, // this could be redundant as we are already saving this in the incomingMonitorRequest. we should remove this in the future.
+                },
+                props: {
+                    isRoot: true,
+                },
+            });
+            logger.debug(`${dataToProcess.monitorId.toString()} - Monitor Updated`);
+        }
+        if (monitor.monitorType === MonitorType.Server &&
+            dataToProcess.requestReceivedAt) {
+            await MonitorService.updateOneById({
+                id: monitor.id,
+                data: {
+                    serverMonitorRequestReceivedAt: dataToProcess.requestReceivedAt,
+                    serverMonitorResponse: dataToProcess, // this could be redundant as we are already saving this in the incomingMonitorRequest. we should remove this in the future.
+                },
+                props: {
+                    isRoot: true,
+                },
+            });
+        }
+        await this.saveMonitorMetrics({
+            monitorId: monitor.id,
+            projectId: monitor.projectId,
+            dataToProcess: dataToProcess,
+        });
+        const monitorSteps = monitor.monitorSteps;
+        if (!((_a = monitorSteps.data) === null || _a === void 0 ? void 0 : _a.monitorStepsInstanceArray) ||
+            ((_b = monitorSteps.data) === null || _b === void 0 ? void 0 : _b.monitorStepsInstanceArray.length) === 0) {
+            // no steps, ignore everything. This happens when the monitor is updated shortly after the probing attempt.
+            logger.debug(`${dataToProcess.monitorId.toString()} - No monitoring steps.`);
+            return response;
+        }
+        // auto resolve criteria Id's.
+        const criteriaInstances = monitorSteps.data.monitorStepsInstanceArray
+            .map((step) => {
+            var _a;
+            return (_a = step.data) === null || _a === void 0 ? void 0 : _a.monitorCriteria;
+        })
+            .filter((criteria) => {
+            return Boolean(criteria);
+        })
+            .map((criteria) => {
+            var _a;
+            return [...(((_a = criteria === null || criteria === void 0 ? void 0 : criteria.data) === null || _a === void 0 ? void 0 : _a.monitorCriteriaInstanceArray) || [])];
+        })
+            .flat();
+        const autoResolveCriteriaInstanceIdIncidentIdsDictionary = {};
+        const criteriaInstanceMap = {};
+        for (const criteriaInstance of criteriaInstances) {
+            criteriaInstanceMap[((_c = criteriaInstance.data) === null || _c === void 0 ? void 0 : _c.id) || ""] = criteriaInstance;
+            if (((_d = criteriaInstance.data) === null || _d === void 0 ? void 0 : _d.incidents) &&
+                ((_e = criteriaInstance.data) === null || _e === void 0 ? void 0 : _e.incidents.length) > 0) {
+                for (const incidentTemplate of criteriaInstance.data.incidents) {
+                    if (incidentTemplate.autoResolveIncident) {
+                        if (!autoResolveCriteriaInstanceIdIncidentIdsDictionary[criteriaInstance.data.id.toString()]) {
+                            autoResolveCriteriaInstanceIdIncidentIdsDictionary[criteriaInstance.data.id.toString()] = [];
+                        }
+                        (_f = autoResolveCriteriaInstanceIdIncidentIdsDictionary[criteriaInstance.data.id.toString()]) === null || _f === void 0 ? void 0 : _f.push(incidentTemplate.id);
+                    }
+                }
+            }
+        }
+        const monitorStep = monitorSteps.data.monitorStepsInstanceArray[0];
+        if (dataToProcess.monitorStepId) {
+            monitorSteps.data.monitorStepsInstanceArray.find((monitorStep) => {
+                return (monitorStep.id.toString() ===
+                    dataToProcess.monitorStepId.toString());
+            });
+        }
+        if (!monitorStep) {
+            // no steps, ignore everything. This happens when the monitor is updated shortly after the probing attempt.
+            return response;
+        }
+        // now process the monitor step
+        response.ingestedMonitorStepId = monitorStep.id;
+        //find next monitor step after this one.
+        const nextMonitorStepIndex = monitorSteps.data.monitorStepsInstanceArray.findIndex((step) => {
+            return step.id.toString() === monitorStep.id.toString();
+        });
+        response.nextMonitorStepId =
+            (_g = monitorSteps.data.monitorStepsInstanceArray[nextMonitorStepIndex + 1]) === null || _g === void 0 ? void 0 : _g.id;
+        // now process probe response monitors
+        response = await MonitorResourceUtil.processMonitorStep({
+            dataToProcess: dataToProcess,
+            monitorStep: monitorStep,
+            monitor: monitor,
+            probeApiIngestResponse: response,
+        });
+        if (response.criteriaMetId && response.rootCause) {
+            logger.debug(`${dataToProcess.monitorId.toString()} - Criteria met: ${response.criteriaMetId}`);
+            logger.debug(`${dataToProcess.monitorId.toString()} - Root cause: ${response.rootCause}`);
+            let telemetryQuery = undefined;
+            if (dataToProcess && dataToProcess.logQuery) {
+                telemetryQuery = {
+                    telemetryQuery: dataToProcess.logQuery,
+                    telemetryType: TelemetryType.Log,
+                };
+            }
+            if (dataToProcess && dataToProcess.spanQuery) {
+                telemetryQuery = {
+                    telemetryQuery: dataToProcess.spanQuery,
+                    telemetryType: TelemetryType.Trace,
+                };
+            }
+            await this.criteriaMetCreateIncidentsAndUpdateMonitorStatus({
+                monitor: monitor,
+                rootCause: response.rootCause,
+                dataToProcess: dataToProcess,
+                autoResolveCriteriaInstanceIdIncidentIdsDictionary,
+                criteriaInstance: criteriaInstanceMap[response.criteriaMetId],
+                props: {
+                    telemetryQuery: telemetryQuery,
+                },
+            });
+        }
+        else if (!response.criteriaMetId &&
+            monitorSteps.data.defaultMonitorStatusId &&
+            ((_h = monitor.currentMonitorStatusId) === null || _h === void 0 ? void 0 : _h.toString()) !==
+                monitorSteps.data.defaultMonitorStatusId.toString()) {
+            logger.debug(`${dataToProcess.monitorId.toString()} - No criteria met. Change to default status.`);
+            await this.checkOpenIncidentsAndCloseIfResolved({
+                monitorId: monitor.id,
+                autoResolveCriteriaInstanceIdIncidentIdsDictionary,
+                rootCause: "No monitoring criteria met. Change to default status.",
+                criteriaInstance: null, // no criteria met!
+                dataToProcess: dataToProcess,
+            });
+            // if no criteria is met then update monitor to default state.
+            const monitorStatusTimeline = new MonitorStatusTimeline();
+            monitorStatusTimeline.monitorId = monitor.id;
+            monitorStatusTimeline.monitorStatusId =
+                monitorSteps.data.defaultMonitorStatusId;
+            monitorStatusTimeline.projectId = monitor.projectId;
+            monitorStatusTimeline.statusChangeLog = JSON.parse(JSON.stringify(dataToProcess));
+            monitorStatusTimeline.rootCause =
+                "No monitoring criteria met. Change to default status. ";
+            await MonitorStatusTimelineService.create({
+                data: monitorStatusTimeline,
+                props: {
+                    isRoot: true,
+                },
+            });
+        }
+        return response;
+    }
+    static async saveMonitorMetrics(data) {
+        if (!data.monitorId) {
+            return;
+        }
+        if (!data.projectId) {
+            return;
+        }
+        if (!data.dataToProcess) {
+            return;
+        }
+        const itemsToSave = [];
+        if (data.dataToProcess.basicInfrastructureMetrics) {
+            // store cpu, memory, disk metrics.
+            if (data.dataToProcess.requestReceivedAt) {
+                let isOnline = true;
+                const differenceInMinutes = OneUptimeDate.getDifferenceInMinutes(data.dataToProcess.requestReceivedAt, OneUptimeDate.getCurrentDate());
+                if (differenceInMinutes > 2) {
+                    isOnline = false;
+                }
+                const monitorMetricsByMinute = new MonitorMetricsByMinute();
+                monitorMetricsByMinute.monitorId = data.monitorId;
+                monitorMetricsByMinute.projectId = data.projectId;
+                monitorMetricsByMinute.metricType = CheckOn.IsOnline;
+                monitorMetricsByMinute.metricValue = isOnline ? 1 : 0;
+                itemsToSave.push(monitorMetricsByMinute);
+            }
+            const basicMetrics = data.dataToProcess.basicInfrastructureMetrics;
+            if (!basicMetrics) {
+                return;
+            }
+            if (basicMetrics.cpuMetrics) {
+                const monitorMetricsByMinute = new MonitorMetricsByMinute();
+                monitorMetricsByMinute.monitorId = data.monitorId;
+                monitorMetricsByMinute.projectId = data.projectId;
+                monitorMetricsByMinute.metricType = CheckOn.CPUUsagePercent;
+                monitorMetricsByMinute.metricValue =
+                    basicMetrics.cpuMetrics.percentUsed;
+                itemsToSave.push(monitorMetricsByMinute);
+            }
+            if (basicMetrics.memoryMetrics) {
+                const monitorMetricsByMinute = new MonitorMetricsByMinute();
+                monitorMetricsByMinute.monitorId = data.monitorId;
+                monitorMetricsByMinute.projectId = data.projectId;
+                monitorMetricsByMinute.metricType = CheckOn.MemoryUsagePercent;
+                monitorMetricsByMinute.metricValue =
+                    basicMetrics.memoryMetrics.percentUsed;
+                itemsToSave.push(monitorMetricsByMinute);
+            }
+            if (basicMetrics.diskMetrics && basicMetrics.diskMetrics.length > 0) {
+                for (const diskMetric of basicMetrics.diskMetrics) {
+                    const monitorMetricsByMinute = new MonitorMetricsByMinute();
+                    monitorMetricsByMinute.monitorId = data.monitorId;
+                    monitorMetricsByMinute.projectId = data.projectId;
+                    monitorMetricsByMinute.metricType = CheckOn.DiskUsagePercent;
+                    monitorMetricsByMinute.metricValue = diskMetric.percentUsed;
+                    monitorMetricsByMinute.miscData = {
+                        diskPath: diskMetric.diskPath,
+                    };
+                    itemsToSave.push(monitorMetricsByMinute);
+                }
+            }
+        }
+        if (data.dataToProcess.responseTimeInMs) {
+            const monitorMetricsByMinute = new MonitorMetricsByMinute();
+            monitorMetricsByMinute.monitorId = data.monitorId;
+            monitorMetricsByMinute.projectId = data.projectId;
+            monitorMetricsByMinute.metricType = CheckOn.ResponseTime;
+            monitorMetricsByMinute.metricValue = data.dataToProcess.responseTimeInMs;
+            monitorMetricsByMinute.miscData = {
+                probeId: data.dataToProcess.probeId.toString(),
+            };
+            itemsToSave.push(monitorMetricsByMinute);
+        }
+        if (data.dataToProcess.isOnline !== undefined) {
+            const monitorMetricsByMinute = new MonitorMetricsByMinute();
+            monitorMetricsByMinute.monitorId = data.monitorId;
+            monitorMetricsByMinute.projectId = data.projectId;
+            monitorMetricsByMinute.metricType = CheckOn.IsOnline;
+            monitorMetricsByMinute.metricValue = 0;
+            monitorMetricsByMinute.miscData = {
+                probeId: data.dataToProcess.probeId.toString(),
+            };
+            if (data.dataToProcess.isOnline) {
+                monitorMetricsByMinute.metricValue = 1;
+            }
+            itemsToSave.push(monitorMetricsByMinute);
+        }
+        if (data.dataToProcess.responseCode) {
+            const monitorMetricsByMinute = new MonitorMetricsByMinute();
+            monitorMetricsByMinute.monitorId = data.monitorId;
+            monitorMetricsByMinute.projectId = data.projectId;
+            monitorMetricsByMinute.metricType = CheckOn.ResponseStatusCode;
+            monitorMetricsByMinute.metricValue = data.dataToProcess.responseCode;
+            monitorMetricsByMinute.miscData = {
+                probeId: data.dataToProcess.probeId.toString(),
+            };
+            itemsToSave.push(monitorMetricsByMinute);
+        }
+        if (data.dataToProcess.syntheticMonitorResponse) {
+            for (const syntheticMonitorResponse of data.dataToProcess.syntheticMonitorResponse || []) {
+                const monitorMetricsByMinute = new MonitorMetricsByMinute();
+                monitorMetricsByMinute.monitorId = data.monitorId;
+                monitorMetricsByMinute.projectId = data.projectId;
+                monitorMetricsByMinute.metricType = CheckOn.ExecutionTime;
+                monitorMetricsByMinute.metricValue =
+                    syntheticMonitorResponse.executionTimeInMS;
+                monitorMetricsByMinute.miscData = {
+                    probeId: data.dataToProcess.probeId.toString(),
+                    browserType: syntheticMonitorResponse.browserType,
+                    screenSizeType: syntheticMonitorResponse.screenSizeType,
+                };
+                itemsToSave.push(monitorMetricsByMinute);
+            }
+        }
+        if (data.dataToProcess.customCodeMonitorResponse) {
+            const customCodeMonitorResponse = data.dataToProcess.customCodeMonitorResponse;
+            const monitorMetricsByMinute = new MonitorMetricsByMinute();
+            monitorMetricsByMinute.monitorId = data.monitorId;
+            monitorMetricsByMinute.projectId = data.projectId;
+            monitorMetricsByMinute.metricType = CheckOn.ExecutionTime;
+            monitorMetricsByMinute.metricValue =
+                customCodeMonitorResponse.executionTimeInMS;
+            monitorMetricsByMinute.miscData = {
+                probeId: data.dataToProcess.probeId.toString(),
+            };
+            itemsToSave.push(monitorMetricsByMinute);
+        }
+        await MonitorMetricsByMinuteService.createMany({
+            items: itemsToSave,
+            props: {
+                isRoot: true,
+            },
+        });
+    }
+    static async checkOpenIncidentsAndCloseIfResolved(input) {
+        // check active incidents and if there are open incidents, do not cretae anothr incident.
+        const openIncidents = await IncidentService.findBy({
+            query: {
+                monitors: [input.monitorId],
+                currentIncidentState: {
+                    isResolvedState: false,
+                },
+            },
+            skip: 0,
+            limit: LIMIT_PER_PROJECT,
+            select: {
+                _id: true,
+                createdCriteriaId: true,
+                createdIncidentTemplateId: true,
+                projectId: true,
+            },
+            props: {
+                isRoot: true,
+            },
+        });
+        // check if should close the incident.
+        for (const openIncident of openIncidents) {
+            const shouldClose = MonitorResourceUtil.shouldCloseIncident({
+                openIncident,
+                autoResolveCriteriaInstanceIdIncidentIdsDictionary: input.autoResolveCriteriaInstanceIdIncidentIdsDictionary,
+                criteriaInstance: input.criteriaInstance,
+            });
+            if (shouldClose) {
+                // then resolve incident.
+                await MonitorResourceUtil.resolveOpenIncident({
+                    openIncident: openIncident,
+                    rootCause: input.rootCause,
+                    dataToProcess: input.dataToProcess,
+                });
+            }
+        }
+        return openIncidents;
+    }
+    static async criteriaMetCreateIncidentsAndUpdateMonitorStatus(input) {
+        // criteria filters are met, now process the actions.
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+        if (((_a = input.criteriaInstance.data) === null || _a === void 0 ? void 0 : _a.changeMonitorStatus) &&
+            ((_b = input.criteriaInstance.data) === null || _b === void 0 ? void 0 : _b.monitorStatusId) &&
+            ((_c = input.criteriaInstance.data) === null || _c === void 0 ? void 0 : _c.monitorStatusId.toString()) !==
+                ((_d = input.monitor.currentMonitorStatusId) === null || _d === void 0 ? void 0 : _d.toString())) {
+            logger.debug(`${(_e = input.monitor.id) === null || _e === void 0 ? void 0 : _e.toString()} - Change monitor status to ${(_f = input.criteriaInstance.data) === null || _f === void 0 ? void 0 : _f.monitorStatusId.toString()}`);
+            // change monitor status
+            const monitorStatusId = (_g = input.criteriaInstance.data) === null || _g === void 0 ? void 0 : _g.monitorStatusId;
+            //change monitor status.
+            const monitorStatusTimeline = new MonitorStatusTimeline();
+            monitorStatusTimeline.monitorId = input.monitor.id;
+            monitorStatusTimeline.monitorStatusId = monitorStatusId;
+            monitorStatusTimeline.projectId = input.monitor.projectId;
+            monitorStatusTimeline.statusChangeLog = JSON.parse(JSON.stringify(input.dataToProcess));
+            monitorStatusTimeline.rootCause = input.rootCause;
+            await MonitorStatusTimelineService.create({
+                data: monitorStatusTimeline,
+                props: {
+                    isRoot: true,
+                },
+            });
+        }
+        // check open incidents
+        logger.debug(`${(_h = input.monitor.id) === null || _h === void 0 ? void 0 : _h.toString()} - Check open incidents.`);
+        // check active incidents and if there are open incidents, do not cretae anothr incident.
+        const openIncidents = await this.checkOpenIncidentsAndCloseIfResolved({
+            monitorId: input.monitor.id,
+            autoResolveCriteriaInstanceIdIncidentIdsDictionary: input.autoResolveCriteriaInstanceIdIncidentIdsDictionary,
+            rootCause: input.rootCause,
+            criteriaInstance: input.criteriaInstance,
+            dataToProcess: input.dataToProcess,
+        });
+        if ((_j = input.criteriaInstance.data) === null || _j === void 0 ? void 0 : _j.createIncidents) {
+            // create incidents
+            for (const criteriaIncident of ((_k = input.criteriaInstance.data) === null || _k === void 0 ? void 0 : _k.incidents) ||
+                []) {
+                // should create incident.
+                const alreadyOpenIncident = openIncidents.find((incident) => {
+                    var _a;
+                    return (incident.createdCriteriaId ===
+                        ((_a = input.criteriaInstance.data) === null || _a === void 0 ? void 0 : _a.id.toString()) &&
+                        incident.createdIncidentTemplateId ===
+                            criteriaIncident.id.toString());
+                });
+                const hasAlreadyOpenIncident = Boolean(alreadyOpenIncident);
+                logger.debug(`${(_l = input.monitor.id) === null || _l === void 0 ? void 0 : _l.toString()} - Open Incident ${(_m = alreadyOpenIncident === null || alreadyOpenIncident === void 0 ? void 0 : alreadyOpenIncident.id) === null || _m === void 0 ? void 0 : _m.toString()}`);
+                logger.debug(`${(_o = input.monitor.id) === null || _o === void 0 ? void 0 : _o.toString()} - Has open incident ${hasAlreadyOpenIncident}`);
+                if (hasAlreadyOpenIncident) {
+                    continue;
+                }
+                // create incident here.
+                logger.debug(`${(_p = input.monitor.id) === null || _p === void 0 ? void 0 : _p.toString()} - Create incident.`);
+                const incident = new Incident();
+                incident.title = criteriaIncident.title;
+                incident.description = criteriaIncident.description;
+                if (!criteriaIncident.incidentSeverityId) {
+                    // pick the critical criteria.
+                    const severity = await IncidentSeverityService.findOneBy({
+                        query: {
+                            projectId: input.monitor.projectId,
+                        },
+                        sort: {
+                            order: SortOrder.Ascending,
+                        },
+                        props: {
+                            isRoot: true,
+                        },
+                        select: {
+                            _id: true,
+                        },
+                    });
+                    if (!severity) {
+                        throw new BadDataException("Project does not have incident severity");
+                    }
+                    else {
+                        incident.incidentSeverityId = severity.id;
+                    }
+                }
+                else {
+                    incident.incidentSeverityId = criteriaIncident.incidentSeverityId;
+                }
+                incident.monitors = [input.monitor];
+                incident.projectId = input.monitor.projectId;
+                incident.rootCause = input.rootCause;
+                incident.createdStateLog = JSON.parse(JSON.stringify(input.dataToProcess, null, 2));
+                incident.createdCriteriaId = input.criteriaInstance.data.id.toString();
+                incident.createdIncidentTemplateId = criteriaIncident.id.toString();
+                incident.onCallDutyPolicies =
+                    ((_q = criteriaIncident.onCallPolicyIds) === null || _q === void 0 ? void 0 : _q.map((id) => {
+                        const onCallPolicy = new OnCallDutyPolicy();
+                        onCallPolicy._id = id.toString();
+                        return onCallPolicy;
+                    })) || [];
+                incident.isCreatedAutomatically = true;
+                if (input.props.telemetryQuery) {
+                    incident.telemetryQuery = input.props.telemetryQuery;
+                }
+                if (input.dataToProcess &&
+                    input.dataToProcess.probeId) {
+                    incident.createdByProbeId = input.dataToProcess.probeId;
+                }
+                if (criteriaIncident.remediationNotes) {
+                    incident.remediationNotes = criteriaIncident.remediationNotes;
+                }
+                await IncidentService.create({
+                    data: incident,
+                    props: {
+                        isRoot: true,
+                    },
+                });
+            }
+        }
+    }
+    static async resolveOpenIncident(input) {
+        const resolvedStateId = await IncidentStateTimelineService.getResolvedStateIdForProject(input.openIncident.projectId);
+        const incidentStateTimeline = new IncidentStateTimeline();
+        incidentStateTimeline.incidentId = input.openIncident.id;
+        incidentStateTimeline.incidentStateId = resolvedStateId;
+        incidentStateTimeline.projectId = input.openIncident.projectId;
+        if (input.rootCause) {
+            incidentStateTimeline.rootCause =
+                "Incident autoresolved because autoresolve is set to true in monitor criteria. " +
+                    input.rootCause;
+        }
+        if (input.dataToProcess) {
+            incidentStateTimeline.stateChangeLog = JSON.parse(JSON.stringify(input.dataToProcess));
+        }
+        await IncidentStateTimelineService.create({
+            data: incidentStateTimeline,
+            props: {
+                isRoot: true,
+            },
+        });
+    }
+    static shouldCloseIncident(input) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        if (((_a = input.openIncident.createdCriteriaId) === null || _a === void 0 ? void 0 : _a.toString()) ===
+            ((_c = (_b = input.criteriaInstance) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.id.toString())) {
+            // same incident active. So, do not close.
+            return false;
+        }
+        // If antoher criteria is active then, check if the incident id is present in the map.
+        if (!((_d = input.openIncident.createdCriteriaId) === null || _d === void 0 ? void 0 : _d.toString())) {
+            return false;
+        }
+        if (!((_e = input.openIncident.createdIncidentTemplateId) === null || _e === void 0 ? void 0 : _e.toString())) {
+            return false;
+        }
+        if (input.autoResolveCriteriaInstanceIdIncidentIdsDictionary[(_f = input.openIncident.createdCriteriaId) === null || _f === void 0 ? void 0 : _f.toString()]) {
+            if ((_h = input.autoResolveCriteriaInstanceIdIncidentIdsDictionary[(_g = input.openIncident.createdCriteriaId) === null || _g === void 0 ? void 0 : _g.toString()]) === null || _h === void 0 ? void 0 : _h.includes((_j = input.openIncident.createdIncidentTemplateId) === null || _j === void 0 ? void 0 : _j.toString())) {
+                return true;
+            }
+        }
+        return false;
+    }
+    static async processMonitorStep(input) {
+        // process monitor step here.
+        var _a, _b, _c;
+        const criteria = (_a = input.monitorStep.data) === null || _a === void 0 ? void 0 : _a.monitorCriteria;
+        if (!criteria || !criteria.data) {
+            // do nothing as there's no criteria to process.
+            return input.probeApiIngestResponse;
+        }
+        for (const criteriaInstance of criteria.data.monitorCriteriaInstanceArray) {
+            const rootCause = await MonitorResourceUtil.processMonitorCriteiaInstance({
+                dataToProcess: input.dataToProcess,
+                monitorStep: input.monitorStep,
+                monitor: input.monitor,
+                probeApiIngestResponse: input.probeApiIngestResponse,
+                criteriaInstance: criteriaInstance,
+            });
+            if (rootCause) {
+                input.probeApiIngestResponse.criteriaMetId = (_b = criteriaInstance.data) === null || _b === void 0 ? void 0 : _b.id;
+                input.probeApiIngestResponse.rootCause = `
+**This incident is created because the following criteria was met**: 
+
+**Criteria Name**: ${(_c = criteriaInstance.data) === null || _c === void 0 ? void 0 : _c.name}
+`;
+                if (rootCause) {
+                    input.probeApiIngestResponse.rootCause += `
+**Filter Conditions Met**: ${rootCause}
+`;
+                }
+                if (input.dataToProcess.failureCause) {
+                    input.probeApiIngestResponse.rootCause += `
+**Cause**: ${input.dataToProcess.failureCause || ""}
+`;
+                }
+                break;
+            }
+        }
+        return input.probeApiIngestResponse;
+    }
+    static async processMonitorCriteiaInstance(input) {
+        // returns root cause if any. Otherwise criteria is not met.
+        // process monitor criteria instance here.
+        const rootCause = await MonitorResourceUtil.isMonitorInstanceCriteriaFiltersMet({
+            dataToProcess: input.dataToProcess,
+            monitorStep: input.monitorStep,
+            monitor: input.monitor,
+            probeApiIngestResponse: input.probeApiIngestResponse,
+            criteriaInstance: input.criteriaInstance,
+        });
+        // do nothing as there's no criteria to process.
+        return rootCause;
+    }
+    static async isMonitorInstanceCriteriaFiltersMet(input) {
+        var _a, _b, _c, _d, _e;
+        // returns root cause if any. Otherwise criteria is not met.
+        let finalResult = "All filters met. ";
+        if (FilterCondition.Any === ((_a = input.criteriaInstance.data) === null || _a === void 0 ? void 0 : _a.filterCondition)) {
+            finalResult = null; // set to false as we need to check if any of the filters are met.
+        }
+        for (const criteriaFilter of ((_b = input.criteriaInstance.data) === null || _b === void 0 ? void 0 : _b.filters) || []) {
+            const rootCause = await MonitorResourceUtil.isMonitorInstanceCriteriaFilterMet({
+                dataToProcess: input.dataToProcess,
+                monitorStep: input.monitorStep,
+                monitor: input.monitor,
+                probeApiIngestResponse: input.probeApiIngestResponse,
+                criteriaInstance: input.criteriaInstance,
+                criteriaFilter: criteriaFilter,
+            });
+            const didMeetCriteria = Boolean(rootCause);
+            if (FilterCondition.Any === ((_c = input.criteriaInstance.data) === null || _c === void 0 ? void 0 : _c.filterCondition) &&
+                didMeetCriteria === true) {
+                finalResult = rootCause;
+            }
+            if (FilterCondition.All === ((_d = input.criteriaInstance.data) === null || _d === void 0 ? void 0 : _d.filterCondition) &&
+                didMeetCriteria === false) {
+                finalResult = null;
+                break;
+            }
+            if (FilterCondition.All === ((_e = input.criteriaInstance.data) === null || _e === void 0 ? void 0 : _e.filterCondition) &&
+                didMeetCriteria &&
+                rootCause) {
+                finalResult += `
+
+        - ${rootCause}`; // in markdown format.
+            }
+        }
+        return finalResult;
+    }
+    static async isMonitorInstanceCriteriaFilterMet(input) {
+        // returns root cause if any. Otherwise criteria is not met.
+        // process monitor criteria filter here.
+        var _a;
+        if (input.criteriaFilter.checkOn === CheckOn.JavaScriptExpression) {
+            let storageMap = {};
+            if (input.monitor.monitorType === MonitorType.API ||
+                input.monitor.monitorType === MonitorType.Website) {
+                // try to parse json
+                let responseBody = null;
+                try {
+                    responseBody = JSON.parse(input.dataToProcess
+                        .responseBody || "{}");
+                }
+                catch (err) {
+                    responseBody = input.dataToProcess
+                        .responseBody;
+                }
+                if (typeof responseBody === Typeof.String &&
+                    (responseBody === null || responseBody === void 0 ? void 0 : responseBody.toString()) === "") {
+                    // if empty string then set to empty object.
+                    responseBody = {};
+                }
+                storageMap = {
+                    responseBody: responseBody,
+                    responseHeaders: input.dataToProcess
+                        .responseHeaders,
+                    responseStatusCode: input.dataToProcess
+                        .responseCode,
+                    responseTimeInMs: input.dataToProcess
+                        .responseTimeInMs,
+                    isOnline: input.dataToProcess.isOnline,
+                };
+            }
+            if (input.monitor.monitorType === MonitorType.IncomingRequest) {
+                storageMap = {
+                    requestBody: input.dataToProcess
+                        .requestBody,
+                    requestHeaders: input.dataToProcess
+                        .requestHeaders,
+                };
+            }
+            // now evaluate the expression.
+            let expression = input.criteriaFilter.value;
+            expression = VMUtil.replaceValueInPlace(storageMap, expression, false); // now pass this to the VM.
+            const code = `return Boolean(${expression});`;
+            let result = null;
+            try {
+                result = await VMUtil.runCodeInSandbox({
+                    code: code,
+                    options: {
+                        args: {},
+                    },
+                });
+            }
+            catch (err) {
+                logger.error(err);
+                return null;
+            }
+            if (result.returnValue) {
+                return `JavaScript Expression - ${expression} - evaluated to true.`;
+            }
+            return null; // if true then return null.
+        }
+        if (input.monitor.monitorType === MonitorType.API ||
+            input.monitor.monitorType === MonitorType.Website ||
+            input.monitor.monitorType === MonitorType.IP ||
+            input.monitor.monitorType === MonitorType.Ping ||
+            input.monitor.monitorType === MonitorType.Port) {
+            const apiRequestCriteriaResult = await APIRequestCriteria.isMonitorInstanceCriteriaFilterMet({
+                dataToProcess: input.dataToProcess,
+                criteriaFilter: input.criteriaFilter,
+            });
+            if (apiRequestCriteriaResult) {
+                return apiRequestCriteriaResult;
+            }
+        }
+        if (input.monitor.monitorType === MonitorType.CustomJavaScriptCode &&
+            input.dataToProcess.customCodeMonitorResponse) {
+            const criteriaResult = await CustomCodeMonitoringCriteria.isMonitorInstanceCriteriaFilterMet({
+                monitorResponse: input.dataToProcess
+                    .customCodeMonitorResponse,
+                criteriaFilter: input.criteriaFilter,
+            });
+            if (criteriaResult) {
+                return criteriaResult;
+            }
+        }
+        if (input.monitor.monitorType === MonitorType.SyntheticMonitor &&
+            input.dataToProcess.syntheticMonitorResponse) {
+            const criteriaResult = await SyntheticMonitoringCriteria.isMonitorInstanceCriteriaFilterMet({
+                monitorResponse: input.dataToProcess
+                    .syntheticMonitorResponse || [],
+                criteriaFilter: input.criteriaFilter,
+            });
+            if (criteriaResult) {
+                return criteriaResult;
+            }
+        }
+        if (input.monitor.monitorType === MonitorType.IncomingRequest) {
+            logger.debug(`${(_a = input.monitor.id) === null || _a === void 0 ? void 0 : _a.toString()} - Incoming Request Monitor. Checking criteria filter.`);
+            //check  incoming request
+            const incomingRequestResult = await IncomingRequestCriteria.isMonitorInstanceCriteriaFilterMet({
+                dataToProcess: input.dataToProcess,
+                criteriaFilter: input.criteriaFilter,
+            });
+            if (incomingRequestResult) {
+                return incomingRequestResult;
+            }
+        }
+        if (input.monitor.monitorType === MonitorType.SSLCertificate) {
+            // check server monitor
+            const sslMonitorResult = await SSLMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+                dataToProcess: input.dataToProcess,
+                criteriaFilter: input.criteriaFilter,
+            });
+            if (sslMonitorResult) {
+                return sslMonitorResult;
+            }
+        }
+        if (input.monitor.monitorType === MonitorType.Server) {
+            // check server monitor
+            const serverMonitorResult = await ServerMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+                dataToProcess: input.dataToProcess,
+                criteriaFilter: input.criteriaFilter,
+            });
+            if (serverMonitorResult) {
+                return serverMonitorResult;
+            }
+        }
+        if (input.monitor.monitorType === MonitorType.Logs) {
+            // check server monitor
+            const logMonitorResult = await LogMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+                dataToProcess: input.dataToProcess,
+                criteriaFilter: input.criteriaFilter,
+            });
+            if (logMonitorResult) {
+                return logMonitorResult;
+            }
+        }
+        if (input.monitor.monitorType === MonitorType.Traces) {
+            // check server monitor
+            const traceMonitorResult = await TraceMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+                dataToProcess: input.dataToProcess,
+                criteriaFilter: input.criteriaFilter,
+            });
+            if (traceMonitorResult) {
+                return traceMonitorResult;
+            }
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=MonitorResource.js.map