@oneuptime/common 10.0.7 → 10.0.8

package/Server/Services/MonitorService.ts

@@ -135,6 +135,15 @@ export class Service extends DatabaseService<Model> {
             monitorDestination = `${monitorDestination} @${firstStep.data.dnsMonitor.hostname}`;
           }
         }
+
+        // For External Status Page monitors, use the statusPageUrl
+        if (
+          monitorType === MonitorType.ExternalStatusPage &&
+          firstStep?.data?.externalStatusPageMonitor
+        ) {
+          monitorDestination =
+            firstStep.data.externalStatusPageMonitor.statusPageUrl || "";
+        }
       }
     }
 

package/Server/Types/Markdown.ts

@@ -103,6 +103,15 @@ export default class Markdown {
     return htmlBody;
   }
 
+  private static escapeHtml(text: string): string {
+    return text
+      .replace(/&/g, "&")
+      .replace(/</g, "&lt;")
+      .replace(/>/g, "&gt;")
+      .replace(/"/g, "&quot;")
+      .replace(/'/g, "&#39;");
+  }
+
   private static getEmailRenderer(): Renderer {
     if (this.emailRenderer !== null) {
       return this.emailRenderer;
@@ -140,7 +149,8 @@ export default class Markdown {
       if (language === "mermaid") {
         return `<div class="mermaid">${code}</div>`;
       }
-      return `<pre><code class="language-${language}">${code}</code></pre>`;
+      const escaped: string = Markdown.escapeHtml(code);
+      return `<pre><code class="language-${language}">${escaped}</code></pre>`;
     };
 
     renderer.heading = function (text, level) {
@@ -160,7 +170,8 @@ export default class Markdown {
 
     // Inline code
     renderer.codespan = function (code) {
-      return `<code class="rounded-md bg-slate-100 px-1.5 py-0.5 text-sm text-slate-700 font-mono">${code}</code>`;
+      const escaped: string = Markdown.escapeHtml(code);
+      return `<code class="rounded-md bg-slate-100 px-1.5 py-0.5 text-sm text-slate-700 font-mono">${escaped}</code>`;
     };
 
     this.docsRenderer = renderer;
@@ -186,7 +197,8 @@ export default class Markdown {
     };
 
     renderer.code = function (code, language) {
-      return `<pre class="language-${language} rounded-md"><code class="language-${language} rounded-md">${code}</code></pre>`;
+      const escaped: string = Markdown.escapeHtml(code);
+      return `<pre class="language-${language} rounded-md"><code class="language-${language} rounded-md">${escaped}</code></pre>`;
     };
 
     renderer.heading = function (text, level) {
@@ -237,7 +249,8 @@ export default class Markdown {
 
     // Inline code
     renderer.codespan = function (code) {
-      return `<code class="rounded-md bg-gray-100 px-1.5 py-0.5 text-sm text-pink-600">${code}</code>`;
+      const escaped: string = Markdown.escapeHtml(code);
+      return `<code class="rounded-md bg-gray-100 px-1.5 py-0.5 text-sm text-pink-600">${escaped}</code>`;
     };
 
     // Horizontal rule

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

@@ -0,0 +1,158 @@
+import DataToProcess from "../DataToProcess";
+import CompareCriteria from "./CompareCriteria";
+import {
+  CheckOn,
+  CriteriaFilter,
+} from "../../../../Types/Monitor/CriteriaFilter";
+import ExternalStatusPageMonitorResponse from "../../../../Types/Monitor/ExternalStatusPageMonitor/ExternalStatusPageMonitorResponse";
+import ProbeMonitorResponse from "../../../../Types/Probe/ProbeMonitorResponse";
+import EvaluateOverTime from "./EvaluateOverTime";
+import CaptureSpan from "../../Telemetry/CaptureSpan";
+import logger from "../../Logger";
+
+export default class ExternalStatusPageMonitorCriteria {
+  @CaptureSpan()
+  public static async isMonitorInstanceCriteriaFilterMet(input: {
+    dataToProcess: DataToProcess;
+    criteriaFilter: CriteriaFilter;
+  }): Promise<string | null> {
+    let threshold: number | string | undefined | null =
+      input.criteriaFilter.value;
+
+    const dataToProcess: ProbeMonitorResponse =
+      input.dataToProcess as ProbeMonitorResponse;
+
+    const externalStatusPageResponse:
+      | ExternalStatusPageMonitorResponse
+      | undefined = dataToProcess.externalStatusPageResponse;
+
+    let overTimeValue: Array<number | boolean> | number | boolean | undefined =
+      undefined;
+
+    if (
+      input.criteriaFilter.evaluateOverTime &&
+      input.criteriaFilter.evaluateOverTimeOptions
+    ) {
+      try {
+        overTimeValue = await EvaluateOverTime.getValueOverTime({
+          projectId: (input.dataToProcess as ProbeMonitorResponse).projectId,
+          monitorId: input.dataToProcess.monitorId!,
+          evaluateOverTimeOptions: input.criteriaFilter.evaluateOverTimeOptions,
+          metricType: input.criteriaFilter.checkOn,
+        });
+
+        if (Array.isArray(overTimeValue) && overTimeValue.length === 0) {
+          overTimeValue = undefined;
+        }
+      } catch (err) {
+        logger.error(
+          `Error in getting over time value for ${input.criteriaFilter.checkOn}`,
+        );
+        logger.error(err);
+        overTimeValue = undefined;
+      }
+    }
+
+    // Check if external status page is online
+    if (input.criteriaFilter.checkOn === CheckOn.ExternalStatusPageIsOnline) {
+      const currentIsOnline: boolean | Array<boolean> =
+        (overTimeValue as Array<boolean>) ||
+        (input.dataToProcess as ProbeMonitorResponse).isOnline;
+
+      return CompareCriteria.compareCriteriaBoolean({
+        value: currentIsOnline,
+        criteriaFilter: input.criteriaFilter,
+      });
+    }
+
+    // Check external status page response time
+    if (
+      input.criteriaFilter.checkOn === CheckOn.ExternalStatusPageResponseTime
+    ) {
+      threshold = CompareCriteria.convertToNumber(threshold);
+
+      if (threshold === null || threshold === undefined) {
+        return null;
+      }
+
+      const currentResponseTime: number | Array<number> =
+        (overTimeValue as Array<number>) ||
+        externalStatusPageResponse?.responseTimeInMs ||
+        (input.dataToProcess as ProbeMonitorResponse).responseTimeInMs;
+
+      if (currentResponseTime === null || currentResponseTime === undefined) {
+        return null;
+      }
+
+      return CompareCriteria.compareCriteriaNumbers({
+        value: currentResponseTime,
+        threshold: threshold as number,
+        criteriaFilter: input.criteriaFilter,
+      });
+    }
+
+    // Check overall status
+    if (
+      input.criteriaFilter.checkOn === CheckOn.ExternalStatusPageOverallStatus
+    ) {
+      if (!externalStatusPageResponse?.overallStatus) {
+        return null;
+      }
+
+      return CompareCriteria.compareCriteriaStrings({
+        value: externalStatusPageResponse.overallStatus,
+        threshold: String(threshold),
+        criteriaFilter: input.criteriaFilter,
+      });
+    }
+
+    // Check component status
+    if (
+      input.criteriaFilter.checkOn === CheckOn.ExternalStatusPageComponentStatus
+    ) {
+      if (
+        !externalStatusPageResponse?.componentStatuses ||
+        externalStatusPageResponse.componentStatuses.length === 0
+      ) {
+        return null;
+      }
+
+      // Check if any component status matches the criteria
+      for (const component of externalStatusPageResponse.componentStatuses) {
+        const result: string | null = CompareCriteria.compareCriteriaStrings({
+          value: component.status,
+          threshold: String(threshold),
+          criteriaFilter: input.criteriaFilter,
+        });
+
+        if (result) {
+          return `Component "${component.name}": ${result}`;
+        }
+      }
+
+      return null;
+    }
+
+    // Check active incidents count
+    if (
+      input.criteriaFilter.checkOn === CheckOn.ExternalStatusPageActiveIncidents
+    ) {
+      threshold = CompareCriteria.convertToNumber(threshold);
+
+      if (threshold === null || threshold === undefined) {
+        return null;
+      }
+
+      const activeIncidents: number =
+        externalStatusPageResponse?.activeIncidentCount || 0;
+
+      return CompareCriteria.compareCriteriaNumbers({
+        value: activeIncidents,
+        threshold: threshold as number,
+        criteriaFilter: input.criteriaFilter,
+      });
+    }
+
+    return null;
+  }
+}

package/Server/Utils/Monitor/MonitorCriteriaEvaluator.ts

@@ -14,6 +14,7 @@ import ExceptionMonitorCriteria from "./Criteria/ExceptionMonitorCriteria";
 import SnmpMonitorCriteria from "./Criteria/SnmpMonitorCriteria";
 import DnsMonitorCriteria from "./Criteria/DnsMonitorCriteria";
 import DomainMonitorCriteria from "./Criteria/DomainMonitorCriteria";
+import ExternalStatusPageMonitorCriteria from "./Criteria/ExternalStatusPageMonitorCriteria";
 import MonitorCriteriaMessageBuilder from "./MonitorCriteriaMessageBuilder";
 import MonitorCriteriaDataExtractor from "./MonitorCriteriaDataExtractor";
 import MonitorCriteriaMessageFormatter from "./MonitorCriteriaMessageFormatter";
@@ -519,6 +520,20 @@ ${contextBlock}
       }
     }
 
+    if (input.monitor.monitorType === MonitorType.ExternalStatusPage) {
+      const externalStatusPageResult: string | null =
+        await ExternalStatusPageMonitorCriteria.isMonitorInstanceCriteriaFilterMet(
+          {
+            dataToProcess: input.dataToProcess,
+            criteriaFilter: input.criteriaFilter,
+          },
+        );
+
+      if (externalStatusPageResult) {
+        return externalStatusPageResult;
+      }
+    }
+
     return null;
   }
 

package/Server/Utils/Monitor/MonitorTemplateUtil.ts

@@ -18,6 +18,9 @@ import DnsMonitorResponse, {
   DnsRecordResponse,
 } from "../../../Types/Monitor/DnsMonitor/DnsMonitorResponse";
 import DomainMonitorResponse from "../../../Types/Monitor/DomainMonitor/DomainMonitorResponse";
+import ExternalStatusPageMonitorResponse, {
+  ExternalStatusPageComponentStatus,
+} from "../../../Types/Monitor/ExternalStatusPageMonitor/ExternalStatusPageMonitorResponse";
 import Typeof from "../../../Types/Typeof";
 import VMUtil from "../VM/VMAPI";
 import DataToProcess from "./DataToProcess";
@@ -298,6 +301,35 @@ export default class MonitorTemplateUtil {
           dnssec: domainResponse?.dnssec,
         } as JSONObject;
       }
+
+      if (data.monitorType === MonitorType.ExternalStatusPage) {
+        const externalStatusPageResponse:
+          | ExternalStatusPageMonitorResponse
+          | undefined = (data.dataToProcess as ProbeMonitorResponse)
+          .externalStatusPageResponse;
+
+        storageMap = {
+          isOnline: (data.dataToProcess as ProbeMonitorResponse).isOnline,
+          responseTimeInMs: externalStatusPageResponse?.responseTimeInMs,
+          failureCause: externalStatusPageResponse?.failureCause,
+          overallStatus: externalStatusPageResponse?.overallStatus,
+          activeIncidentCount: externalStatusPageResponse?.activeIncidentCount,
+        } as JSONObject;
+
+        // Add component statuses
+        if (externalStatusPageResponse?.componentStatuses) {
+          storageMap["componentStatuses"] =
+            externalStatusPageResponse.componentStatuses.map(
+              (component: ExternalStatusPageComponentStatus) => {
+                return {
+                  name: component.name,
+                  status: component.status,
+                  description: component.description,
+                };
+              },
+            );
+        }
+      }
     } catch (err) {
       logger.error(err);
     }

package/Server/Utils/VM/VMRunner.ts

@@ -143,62 +143,100 @@ export default class VMRunner {
             }
           }
 
-          let response: AxiosResponse;
-
-          switch (method) {
-            case "get":
-              response = await axios.get(url, config);
-              break;
-            case "head":
-              response = await axios.head(url, config);
-              break;
-            case "options":
-              response = await axios.options(url, config);
-              break;
-            case "post":
-              response = await axios.post(url, body, config);
-              break;
-            case "put":
-              response = await axios.put(url, body, config);
-              break;
-            case "patch":
-              response = await axios.patch(url, body, config);
-              break;
-            case "delete":
-              response = await axios.delete(url, config);
-              break;
-            case "request":
-              response = await axios.request(
-                config as Parameters<typeof axios.request>[0],
-              );
-              break;
-            default:
-              throw new Error(`Unsupported HTTP method: ${method}`);
-          }
-
-          /*
-           * Convert AxiosHeaders to a plain object before serializing.
-           * JSON.stringify calls AxiosHeaders.toJSON(key) with a truthy key,
-           * which makes it join array headers (like set-cookie) with commas.
-           * This produces invalid Cookie headers when user code forwards them.
+          /**
+           * Helper: convert AxiosHeaders (or any header-like object) to a
+           * plain record so it can be safely JSON-serialised.
            */
-          const plainHeaders: Record<string, unknown> = {};
-
-          if (response.headers) {
-            for (const key of Object.keys(
-              response.headers as Record<string, unknown>,
-            )) {
-              plainHeaders[key] = (response.headers as Record<string, unknown>)[
-                key
-              ];
+          const toPlainHeaders: (
+            headers: unknown,
+          ) => Record<string, unknown> = (
+            headers: unknown,
+          ): Record<string, unknown> => {
+            const plain: Record<string, unknown> = {};
+            if (headers) {
+              for (const hKey of Object.keys(
+                headers as Record<string, unknown>,
+              )) {
+                plain[hKey] = (headers as Record<string, unknown>)[hKey];
+              }
             }
-          }
+            return plain;
+          };
 
-          return JSON.stringify({
-            status: response.status,
-            headers: plainHeaders,
-            data: response.data,
-          });
+          try {
+            let response: AxiosResponse;
+
+            switch (method) {
+              case "get":
+                response = await axios.get(url, config);
+                break;
+              case "head":
+                response = await axios.head(url, config);
+                break;
+              case "options":
+                response = await axios.options(url, config);
+                break;
+              case "post":
+                response = await axios.post(url, body, config);
+                break;
+              case "put":
+                response = await axios.put(url, body, config);
+                break;
+              case "patch":
+                response = await axios.patch(url, body, config);
+                break;
+              case "delete":
+                response = await axios.delete(url, config);
+                break;
+              case "request":
+                response = await axios.request(
+                  config as Parameters<typeof axios.request>[0],
+                );
+                break;
+              default:
+                throw new Error(`Unsupported HTTP method: ${method}`);
+            }
+
+            /*
+             * Convert AxiosHeaders to a plain object before serializing.
+             * JSON.stringify calls AxiosHeaders.toJSON(key) with a truthy key,
+             * which makes it join array headers (like set-cookie) with commas.
+             * This produces invalid Cookie headers when user code forwards them.
+             */
+            return JSON.stringify({
+              status: response.status,
+              headers: toPlainHeaders(response.headers),
+              data: response.data,
+            });
+          } catch (err: unknown) {
+            /*
+             * If this is an axios error with a response (4xx, 5xx, etc.),
+             * return the error details as JSON so the sandbox-side axios
+             * wrapper can reconstruct error.response for user code.
+             */
+            const axiosErr: {
+              isAxiosError?: boolean;
+              response?: AxiosResponse<any, any, Record<string, unknown>>;
+              message?: string;
+            } = err as {
+              isAxiosError?: boolean;
+              response?: AxiosResponse;
+              message?: string;
+            };
+
+            if (axiosErr.isAxiosError && axiosErr.response) {
+              return JSON.stringify({
+                __isAxiosError: true,
+                message: axiosErr.message || "Request failed",
+                status: axiosErr.response.status,
+                statusText: axiosErr.response.statusText,
+                headers: toPlainHeaders(axiosErr.response.headers),
+                data: axiosErr.response.data,
+              });
+            }
+
+            throw err;
+          }
         },
       );
 
@@ -236,6 +274,23 @@ export default class VMRunner {
           }
         }
 
+        function _parseAxiosResult(r) {
+          const parsed = JSON.parse(r);
+          if (parsed && parsed.__isAxiosError) {
+            const err = new Error(parsed.message);
+            err.response = {
+              status: parsed.status,
+              statusText: parsed.statusText,
+              headers: parsed.headers,
+              data: parsed.data,
+            };
+            err.isAxiosError = true;
+            err.status = parsed.status;
+            throw err;
+          }
+          return parsed;
+        }
+
         function _makeAxiosInstance(defaults) {
           function mergeConfig(overrides) {
             if (!defaults && !overrides) return undefined;
@@ -252,7 +307,7 @@ export default class VMRunner {
             const merged = mergeConfig(config);
             if (merged) _assertNoFunctions(merged, 'config');
             const r = await _axiosRef.applySyncPromise(undefined, ['request', '', merged ? JSON.stringify(merged) : undefined]);
-            return JSON.parse(r);
+            return _parseAxiosResult(r);
           }
 
           // Make instance callable: axios(config) or axios(url, config)
@@ -268,46 +323,46 @@ export default class VMRunner {
             const merged = mergeConfig(config);
             if (merged) _assertNoFunctions(merged, 'config');
             const r = await _axiosRef.applySyncPromise(undefined, ['get', url, merged ? JSON.stringify(merged) : undefined]);
-            return JSON.parse(r);
+            return _parseAxiosResult(r);
           };
           instance.head = async (url, config) => {
             const merged = mergeConfig(config);
             if (merged) _assertNoFunctions(merged, 'config');
             const r = await _axiosRef.applySyncPromise(undefined, ['head', url, merged ? JSON.stringify(merged) : undefined]);
-            return JSON.parse(r);
+            return _parseAxiosResult(r);
           };
           instance.options = async (url, config) => {
             const merged = mergeConfig(config);
             if (merged) _assertNoFunctions(merged, 'config');
             const r = await _axiosRef.applySyncPromise(undefined, ['options', url, merged ? JSON.stringify(merged) : undefined]);
-            return JSON.parse(r);
+            return _parseAxiosResult(r);
           };
           instance.post = async (url, data, config) => {
             const merged = mergeConfig(config);
             if (data) _assertNoFunctions(data, 'data');
             if (merged) _assertNoFunctions(merged, 'config');
             const r = await _axiosRef.applySyncPromise(undefined, ['post', url, data ? JSON.stringify(data) : undefined, merged ? JSON.stringify(merged) : undefined]);
-            return JSON.parse(r);
+            return _parseAxiosResult(r);
           };
           instance.put = async (url, data, config) => {
             const merged = mergeConfig(config);
             if (data) _assertNoFunctions(data, 'data');
             if (merged) _assertNoFunctions(merged, 'config');
             const r = await _axiosRef.applySyncPromise(undefined, ['put', url, data ? JSON.stringify(data) : undefined, merged ? JSON.stringify(merged) : undefined]);
-            return JSON.parse(r);
+            return _parseAxiosResult(r);
           };
           instance.patch = async (url, data, config) => {
             const merged = mergeConfig(config);
             if (data) _assertNoFunctions(data, 'data');
             if (merged) _assertNoFunctions(merged, 'config');
             const r = await _axiosRef.applySyncPromise(undefined, ['patch', url, data ? JSON.stringify(data) : undefined, merged ? JSON.stringify(merged) : undefined]);
-            return JSON.parse(r);
+            return _parseAxiosResult(r);
           };
           instance.delete = async (url, config) => {
             const merged = mergeConfig(config);
             if (merged) _assertNoFunctions(merged, 'config');
             const r = await _axiosRef.applySyncPromise(undefined, ['delete', url, merged ? JSON.stringify(merged) : undefined]);
-            return JSON.parse(r);
+            return _parseAxiosResult(r);
           };
           instance.create = (instanceDefaults) => {
             if (instanceDefaults) _assertNoFunctions(instanceDefaults, 'defaults');
@@ -321,7 +376,7 @@ export default class VMRunner {
         const axios = _makeAxiosInstance(null);
       `);
 
-      // crypto (createHash, createHmac, randomBytes) - bridged via applySync
+      // crypto (createHash, createHmac, randomBytes, randomUUID, randomInt) - bridged via applySync
       const cryptoRef: ivm.Reference<
         (op: string, ...args: string[]) => string
       > = new ivm.Reference((op: string, ...args: string[]): string => {
@@ -344,6 +399,13 @@ export default class VMRunner {
             const [size] = args;
             return crypto.randomBytes(parseInt(size!)).toString("hex");
           }
+          case "randomUUID": {
+            return crypto.randomUUID();
+          }
+          case "randomInt": {
+            const [min, max] = args;
+            return String(crypto.randomInt(parseInt(min!), parseInt(max!)));
+          }
           default:
             throw new Error(`Unsupported crypto operation: ${op}`);
         }
@@ -366,6 +428,13 @@ export default class VMRunner {
           randomBytes: (size) => ({
             toString(enc) { return _cryptoRef.applySync(undefined, ['randomBytes', String(size)]); }
           }),
+          randomUUID: () => {
+            return _cryptoRef.applySync(undefined, ['randomUUID']);
+          },
+          randomInt: (minOrMax, max) => {
+            if (max === undefined) { max = minOrMax; minOrMax = 0; }
+            return Number(_cryptoRef.applySync(undefined, ['randomInt', String(minOrMax), String(max)]));
+          },
         };
       `);
 

package/Types/Monitor/CriteriaFilter.ts

@@ -74,6 +74,13 @@ export enum CheckOn {
   DomainNameServer = "Domain Name Server",
   DomainStatusCode = "Domain Status Code",
   DomainIsExpired = "Domain Is Expired",
+
+  // External Status Page monitors.
+  ExternalStatusPageIsOnline = "External Status Page Is Online",
+  ExternalStatusPageOverallStatus = "External Status Page Overall Status",
+  ExternalStatusPageComponentStatus = "External Status Page Component Status",
+  ExternalStatusPageActiveIncidents = "External Status Page Active Incidents",
+  ExternalStatusPageResponseTime = "External Status Page Response Time (in ms)",
 }
 
 export interface ServerMonitorOptions {
@@ -159,7 +166,8 @@ export class CriteriaFilterUtil {
       checkOn === CheckOn.IsOnline ||
       checkOn === CheckOn.SnmpIsOnline ||
       checkOn === CheckOn.DnsIsOnline ||
-      checkOn === CheckOn.DomainIsExpired
+      checkOn === CheckOn.DomainIsExpired ||
+      checkOn === CheckOn.ExternalStatusPageIsOnline
     ) {
       return false;
     }
@@ -229,7 +237,9 @@ export class CriteriaFilterUtil {
       checkOn === CheckOn.SnmpResponseTime ||
       checkOn === CheckOn.SnmpIsOnline ||
       checkOn === CheckOn.DnsResponseTime ||
-      checkOn === CheckOn.DnsIsOnline
+      checkOn === CheckOn.DnsIsOnline ||
+      checkOn === CheckOn.ExternalStatusPageResponseTime ||
+      checkOn === CheckOn.ExternalStatusPageIsOnline
     );
   }
 }

package/Types/Monitor/ExternalStatusPageMonitor/ExternalStatusPageMonitorResponse.ts

@@ -0,0 +1,16 @@
+export interface ExternalStatusPageComponentStatus {
+  name: string;
+  status: string;
+  description?: string | undefined;
+}
+
+export default interface ExternalStatusPageMonitorResponse {
+  isOnline: boolean;
+  overallStatus: string;
+  componentStatuses: Array<ExternalStatusPageComponentStatus>;
+  activeIncidentCount: number;
+  responseTimeInMs: number;
+  failureCause: string;
+  rawBody?: string | undefined;
+  isTimeout?: boolean | undefined;
+}

package/Types/Monitor/ExternalStatusPageProviderType.ts

@@ -0,0 +1,8 @@
+enum ExternalStatusPageProviderType {
+  AtlassianStatuspage = "Atlassian Statuspage",
+  RSS = "RSS",
+  Atom = "Atom",
+  Auto = "Auto",
+}
+
+export default ExternalStatusPageProviderType;