@oneuptime/common 10.0.6 → 10.0.8

package/Server/Middleware/UserAuthorization.ts

@@ -116,6 +116,42 @@ export default class UserMiddleware {
       }
     }
 
+    /*
+     * Also check x-sso-tokens header (mobile app flow).
+     * The header value is a JSON-encoded map of { projectId: ssoToken }.
+     */
+    const ssoTokensHeader: string | undefined = req.headers["x-sso-tokens"] as
+      | string
+      | undefined;
+
+    if (ssoTokensHeader) {
+      try {
+        const headerTokens: Record<string, string> =
+          JSON.parse(ssoTokensHeader);
+
+        for (const projectId of Object.keys(headerTokens)) {
+          const token: string | undefined = headerTokens[projectId];
+
+          if (!token || typeof token !== "string") {
+            continue;
+          }
+
+          try {
+            const decoded: JSONWebTokenData = JSONWebToken.decode(token);
+
+            if (decoded.projectId?.toString() === projectId) {
+              ssoTokens[projectId] = token;
+            }
+          } catch (err) {
+            logger.error(err);
+            continue;
+          }
+        }
+      } catch (err) {
+        logger.error(err);
+      }
+    }
+
     return ssoTokens;
   }
 

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/Services/UserNotificationRuleService.ts

@@ -1110,6 +1110,9 @@ export class Service extends DatabaseService<Model> {
             ...(alert.alertNumber !== undefined && {
               alertNumber: alert.alertNumber,
             }),
+            ...(alert.alertNumberWithPrefix && {
+              alertNumberWithPrefix: alert.alertNumberWithPrefix,
+            }),
             alertId: alert.id!.toString(),
             projectId: alert.projectId!.toString(),
           });
@@ -1187,6 +1190,9 @@ export class Service extends DatabaseService<Model> {
             ...(incident.incidentNumber !== undefined && {
               incidentNumber: incident.incidentNumber,
             }),
+            ...(incident.incidentNumberWithPrefix && {
+              incidentNumberWithPrefix: incident.incidentNumberWithPrefix,
+            }),
             incidentId: incident.id!.toString(),
             projectId: incident.projectId!.toString(),
           });
@@ -1309,6 +1315,83 @@ export class Service extends DatabaseService<Model> {
           });
         });
       }
+
+      // send push notification for incident episode
+      if (
+        options.userNotificationEventType ===
+          UserNotificationEventType.IncidentEpisodeCreated &&
+        incidentEpisode
+      ) {
+        logTimelineItem.status = UserNotificationStatus.Sending;
+        logTimelineItem.statusMessage = `Sending push notification to device.`;
+        logTimelineItem.userPushId = notificationRuleItem.userPush.id!;
+
+        const updatedLog: UserOnCallLogTimeline =
+          await UserOnCallLogTimelineService.create({
+            data: logTimelineItem,
+            props: {
+              isRoot: true,
+            },
+          });
+
+        const pushMessage: PushNotificationMessage =
+          PushNotificationUtil.createIncidentEpisodeCreatedNotification({
+            incidentEpisodeTitle: incidentEpisode.title!,
+            projectName: incidentEpisode.project?.name || "OneUptime",
+            incidentEpisodeViewLink: (
+              await IncidentEpisodeService.getEpisodeLinkInDashboard(
+                incidentEpisode.projectId!,
+                incidentEpisode.id!,
+              )
+            ).toString(),
+            ...(incidentEpisode.episodeNumber !== undefined && {
+              episodeNumber: incidentEpisode.episodeNumber,
+            }),
+            ...(incidentEpisode.episodeNumberWithPrefix && {
+              episodeNumberWithPrefix: incidentEpisode.episodeNumberWithPrefix,
+            }),
+            incidentEpisodeId: incidentEpisode.id!.toString(),
+            projectId: incidentEpisode.projectId!.toString(),
+          });
+
+        PushNotificationService.sendPushNotification(
+          {
+            devices: [
+              {
+                token: notificationRuleItem.userPush.deviceToken!,
+                ...(notificationRuleItem.userPush.deviceName && {
+                  name: notificationRuleItem.userPush.deviceName,
+                }),
+              },
+            ],
+            message: pushMessage,
+            deviceType: notificationRuleItem.userPush
+              .deviceType! as PushDeviceType,
+          },
+          {
+            projectId: options.projectId,
+            userOnCallLogTimelineId: updatedLog.id!,
+            userId: notificationRuleItem.userId!,
+            onCallPolicyId: options.onCallPolicyId,
+            onCallPolicyEscalationRuleId: options.onCallPolicyEscalationRuleId,
+            teamId: options.userBelongsToTeamId,
+            onCallDutyPolicyExecutionLogTimelineId:
+              options.onCallDutyPolicyExecutionLogTimelineId,
+            onCallScheduleId: options.onCallScheduleId,
+          },
+        ).catch(async (err: Error) => {
+          await UserOnCallLogTimelineService.updateOneById({
+            id: updatedLog.id!,
+            data: {
+              status: UserNotificationStatus.Error,
+              statusMessage: err.message || "Error sending push notification.",
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+        });
+      }
     }
 
     if (

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

@@ -23,7 +23,9 @@ export default class BrowserUtil {
     "--disable-dev-shm-usage",
     "--disable-gpu",
     "--disable-software-rasterizer",
-    "--single-process",
+    "--disable-dbus", // no D-Bus daemon in containers
+    "--disable-features=dbus", // additional D-Bus feature gate
+    "--no-zygote", // skip zygote process that fails OOM score adjustments in containers
   ];
 
   // Firefox preferences for stability in containerized environments
@@ -31,8 +33,6 @@ export default class BrowserUtil {
     string,
     string | number | boolean
   > = {
-    "browser.tabs.remote.autostart": false, // disable multi-process (electrolysis)
-    "dom.ipc.processCount": 1, // single content process
     "gfx.webrender.all": false, // disable GPU-based WebRender
     "media.hardware-video-decoding.enabled": false, // disable hardware video decoding
     "layers.acceleration.disabled": true, // disable GPU-accelerated layers

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);
     }