@oneuptime/common 9.5.12 → 10.0.0

package/Server/Services/PushNotificationService.ts

@@ -10,9 +10,16 @@ import {
   VapidPublicKey,
   VapidPrivateKey,
   VapidSubject,
+  ExpoAccessToken,
+  PushNotificationRelayUrl,
 } from "../EnvironmentConfig";
 import webpush from "web-push";
 import { Expo, ExpoPushMessage, ExpoPushTicket } from "expo-server-sdk";
+import API from "../../Utils/API";
+import URL from "../../Types/API/URL";
+import HTTPErrorResponse from "../../Types/API/HTTPErrorResponse";
+import HTTPResponse from "../../Types/API/HTTPResponse";
+import { JSONObject } from "../../Types/JSON";
 import PushNotificationUtil from "../Utils/PushNotificationUtil";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import UserPush from "../../Models/DatabaseModels/UserPush";
@@ -43,7 +50,9 @@ export interface PushNotificationOptions {
 
 export default class PushNotificationService {
   public static isWebPushInitialized = false;
-  private static expoClient: Expo = new Expo();
+  private static expoClient: Expo = new Expo(
+    ExpoAccessToken ? { accessToken: ExpoAccessToken } : undefined,
+  );
 
   public static initializeWebPush(): void {
     if (this.isWebPushInitialized) {
@@ -340,20 +349,33 @@ export default class PushNotificationService {
       );
     }
 
-    try {
-      const dataPayload: { [key: string]: string } = {};
-      if (message.data) {
-        for (const key of Object.keys(message.data)) {
-          dataPayload[key] = String(message.data[key]);
-        }
-      }
-      if (message.url || message.clickAction) {
-        dataPayload["url"] = message.url || message.clickAction || "";
+    const dataPayload: { [key: string]: string } = {};
+    if (message.data) {
+      for (const key of Object.keys(message.data)) {
+        dataPayload[key] = String(message.data[key]);
       }
+    }
+    if (message.url || message.clickAction) {
+      dataPayload["url"] = message.url || message.clickAction || "";
+    }
 
-      const channelId: string =
-        deviceType === PushDeviceType.Android ? "oncall_high" : "default";
+    const channelId: string =
+      deviceType === PushDeviceType.Android ? "oncall_high" : "default";
+
+    // If EXPO_ACCESS_TOKEN is not set, relay through the push notification gateway
+    if (!ExpoAccessToken) {
+      await this.sendViaRelay(
+        expoPushToken,
+        message,
+        dataPayload,
+        channelId,
+        deviceType,
+      );
+      return;
+    }
 
+    // Send directly via Expo SDK
+    try {
       const expoPushMessage: ExpoPushMessage = {
         to: expoPushToken,
         title: message.title,
@@ -403,6 +425,108 @@ export default class PushNotificationService {
     }
   }
 
+  private static async sendViaRelay(
+    expoPushToken: string,
+    message: PushNotificationMessage,
+    dataPayload: { [key: string]: string },
+    channelId: string,
+    deviceType: PushDeviceType,
+  ): Promise<void> {
+    logger.info(
+      `Sending ${deviceType} push notification via relay: ${PushNotificationRelayUrl}`,
+    );
+
+    try {
+      const response: HTTPErrorResponse | HTTPResponse<JSONObject> =
+        await API.post<JSONObject>({
+          url: URL.fromString(PushNotificationRelayUrl),
+          data: {
+            to: expoPushToken,
+            title: message.title || "",
+            body: message.body || "",
+            data: dataPayload,
+            sound: "default",
+            priority: "high",
+            channelId: channelId,
+          },
+        });
+
+      if (response instanceof HTTPErrorResponse) {
+        throw new Error(
+          `Push relay error: ${JSON.stringify(response.jsonData)}`,
+        );
+      }
+
+      logger.info(
+        `Push notification sent via relay successfully to ${deviceType} device`,
+      );
+    } catch (error: any) {
+      logger.error(
+        `Failed to send push notification via relay to ${deviceType} device: ${error.message}`,
+      );
+      throw error;
+    }
+  }
+
+  public static isValidExpoPushToken(token: string): boolean {
+    return Expo.isExpoPushToken(token);
+  }
+
+  public static hasExpoAccessToken(): boolean {
+    return Boolean(ExpoAccessToken);
+  }
+
+  public static async sendRelayPushNotification(data: {
+    to: string;
+    title?: string;
+    body?: string;
+    data?: { [key: string]: string };
+    sound?: string;
+    priority?: string;
+    channelId?: string;
+  }): Promise<void> {
+    if (!ExpoAccessToken) {
+      throw new Error(
+        "Push relay is not configured. EXPO_ACCESS_TOKEN is not set on this server.",
+      );
+    }
+
+    const expoPushMessage: ExpoPushMessage = {
+      to: data.to,
+      title: data.title || "",
+      body: data.body || "",
+      data: data.data || {},
+      sound: (data.sound as "default" | null) || "default",
+      priority: (data.priority as "default" | "normal" | "high") || "high",
+      channelId: data.channelId || "default",
+    };
+
+    const tickets: ExpoPushTicket[] =
+      await this.expoClient.sendPushNotificationsAsync([expoPushMessage]);
+
+    const ticket: ExpoPushTicket | undefined = tickets[0];
+
+    if (ticket && ticket.status === "error") {
+      const errorTicket: ExpoPushTicket & {
+        message?: string;
+        details?: { error?: string };
+      } = ticket as ExpoPushTicket & {
+        message?: string;
+        details?: { error?: string };
+      };
+
+      logger.error(
+        `Push relay: Expo push notification error: ${errorTicket.message}`,
+      );
+
+      throw new Error(
+        `Failed to send push notification: ${errorTicket.message}`,
+      );
+    }
+
+    logger.info(`Push relay: notification sent successfully to ${data.to}`);
+  }
+
   public static async sendPushNotificationToUser(
     userId: ObjectID,
     projectId: ObjectID,

package/Server/Services/UserNotificationRuleService.ts

@@ -69,6 +69,14 @@ import PushNotificationMessage from "../../Types/PushNotification/PushNotificati
 import logger from "../Utils/Logger";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 
+export interface NotificationMethodDescriptor {
+  userEmailId?: ObjectID;
+  userSmsId?: ObjectID;
+  userCallId?: ObjectID;
+  userWhatsAppId?: ObjectID;
+  userPushId?: ObjectID;
+}
+
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
@@ -2207,13 +2215,89 @@ export class Service extends DatabaseService<Model> {
   }
 
   @CaptureSpan()
-  public async addDefaultIncidentNotificationRuleForUser(data: {
+  public async addDefaultNotificationRulesForVerifiedMethod(data: {
     projectId: ObjectID;
     userId: ObjectID;
-    userEmail: UserEmail;
+    notificationMethod: NotificationMethodDescriptor;
   }): Promise<void> {
-    const { projectId, userId, userEmail } = data;
+    const { projectId, userId, notificationMethod } = data;
+
+    await this.createIncidentOnCallRules(projectId, userId, notificationMethod);
+    await this.createAlertOnCallRules(projectId, userId, notificationMethod);
+    await this.createSingleRule(
+      projectId,
+      userId,
+      notificationMethod,
+      NotificationRuleType.ON_CALL_EXECUTED_ALERT_EPISODE,
+    );
+    await this.createSingleRule(
+      projectId,
+      userId,
+      notificationMethod,
+      NotificationRuleType.ON_CALL_EXECUTED_INCIDENT_EPISODE,
+    );
+    await this.createSingleRule(
+      projectId,
+      userId,
+      notificationMethod,
+      NotificationRuleType.WHEN_USER_GOES_ON_CALL,
+    );
+    await this.createSingleRule(
+      projectId,
+      userId,
+      notificationMethod,
+      NotificationRuleType.WHEN_USER_GOES_OFF_CALL,
+    );
+  }
+
+  private applyNotificationMethod(
+    rule: Model,
+    descriptor: NotificationMethodDescriptor,
+  ): void {
+    if (descriptor.userEmailId) {
+      rule.userEmailId = descriptor.userEmailId;
+    }
+    if (descriptor.userSmsId) {
+      rule.userSmsId = descriptor.userSmsId;
+    }
+    if (descriptor.userCallId) {
+      rule.userCallId = descriptor.userCallId;
+    }
+    if (descriptor.userWhatsAppId) {
+      rule.userWhatsAppId = descriptor.userWhatsAppId;
+    }
+    if (descriptor.userPushId) {
+      rule.userPushId = descriptor.userPushId;
+    }
+  }
+
+  private getNotificationMethodQuery(
+    descriptor: NotificationMethodDescriptor,
+  ): Record<string, ObjectID> {
+    const query: Record<string, ObjectID> = {};
+    if (descriptor.userEmailId) {
+      query["userEmailId"] = descriptor.userEmailId;
+    }
+    if (descriptor.userSmsId) {
+      query["userSmsId"] = descriptor.userSmsId;
+    }
+    if (descriptor.userCallId) {
+      query["userCallId"] = descriptor.userCallId;
+    }
+    if (descriptor.userWhatsAppId) {
+      query["userWhatsAppId"] = descriptor.userWhatsAppId;
+    }
+    if (descriptor.userPushId) {
+      query["userPushId"] = descriptor.userPushId;
+    }
+    return query;
+  }
 
+  private async createIncidentOnCallRules(
+    projectId: ObjectID,
+    userId: ObjectID,
+    notificationMethod: NotificationMethodDescriptor,
+  ): Promise<void> {
     const incidentSeverities: Array<IncidentSeverity> =
       await IncidentSeverityService.findBy({
         query: {
@@ -2229,38 +2313,34 @@ export class Service extends DatabaseService<Model> {
         },
       });
 
-    // create for incident severities.
     for (const incidentSeverity of incidentSeverities) {
-      //check if this rule already exists.
       const existingRule: Model | null = await this.findOneBy({
         query: {
           projectId,
           userId,
-          userEmailId: userEmail.id!,
+          ...this.getNotificationMethodQuery(notificationMethod),
           incidentSeverityId: incidentSeverity.id!,
           ruleType: NotificationRuleType.ON_CALL_EXECUTED_INCIDENT,
-        },
+        } as any,
         props: {
           isRoot: true,
         },
       });
 
       if (existingRule) {
-        continue; // skip this rule.
+        continue;
       }
 
-      const notificationRule: Model = new Model();
-
-      notificationRule.projectId = projectId;
-      notificationRule.userId = userId;
-      notificationRule.userEmailId = userEmail.id!;
-      notificationRule.incidentSeverityId = incidentSeverity.id!;
-      notificationRule.notifyAfterMinutes = 0;
-      notificationRule.ruleType =
-        NotificationRuleType.ON_CALL_EXECUTED_INCIDENT;
+      const rule: Model = new Model();
+      rule.projectId = projectId;
+      rule.userId = userId;
+      this.applyNotificationMethod(rule, notificationMethod);
+      rule.incidentSeverityId = incidentSeverity.id!;
+      rule.notifyAfterMinutes = 0;
+      rule.ruleType = NotificationRuleType.ON_CALL_EXECUTED_INCIDENT;
 
       await this.create({
-        data: notificationRule,
+        data: rule,
         props: {
           isRoot: true,
         },
@@ -2268,14 +2348,11 @@ export class Service extends DatabaseService<Model> {
     }
   }
 
-  @CaptureSpan()
-  public async addDefaultAlertNotificationRulesForUser(data: {
-    projectId: ObjectID;
-    userId: ObjectID;
-    userEmail: UserEmail;
-  }): Promise<void> {
-    const { projectId, userId, userEmail } = data;
-
+  private async createAlertOnCallRules(
+    projectId: ObjectID,
+    userId: ObjectID,
+    notificationMethod: NotificationMethodDescriptor,
+  ): Promise<void> {
     const alertSeverities: Array<AlertSeverity> =
       await AlertSeverityService.findBy({
         query: {
@@ -2291,37 +2368,34 @@ export class Service extends DatabaseService<Model> {
         },
       });
 
-    // create for Alert severities.
     for (const alertSeverity of alertSeverities) {
-      //check if this rule already exists.
       const existingRule: Model | null = await this.findOneBy({
         query: {
           projectId,
           userId,
-          userEmailId: userEmail.id!,
+          ...this.getNotificationMethodQuery(notificationMethod),
           alertSeverityId: alertSeverity.id!,
           ruleType: NotificationRuleType.ON_CALL_EXECUTED_ALERT,
-        },
+        } as any,
         props: {
           isRoot: true,
         },
       });
 
       if (existingRule) {
-        continue; // skip this rule.
+        continue;
       }
 
-      const notificationRule: Model = new Model();
-
-      notificationRule.projectId = projectId;
-      notificationRule.userId = userId;
-      notificationRule.userEmailId = userEmail.id!;
-      notificationRule.alertSeverityId = alertSeverity.id!;
-      notificationRule.notifyAfterMinutes = 0;
-      notificationRule.ruleType = NotificationRuleType.ON_CALL_EXECUTED_ALERT;
+      const rule: Model = new Model();
+      rule.projectId = projectId;
+      rule.userId = userId;
+      this.applyNotificationMethod(rule, notificationMethod);
+      rule.alertSeverityId = alertSeverity.id!;
+      rule.notifyAfterMinutes = 0;
+      rule.ruleType = NotificationRuleType.ON_CALL_EXECUTED_ALERT;
 
       await this.create({
-        data: notificationRule,
+        data: rule,
         props: {
           isRoot: true,
         },
@@ -2329,6 +2403,43 @@ export class Service extends DatabaseService<Model> {
     }
   }
 
+  private async createSingleRule(
+    projectId: ObjectID,
+    userId: ObjectID,
+    notificationMethod: NotificationMethodDescriptor,
+    ruleType: NotificationRuleType,
+  ): Promise<void> {
+    const existingRule: Model | null = await this.findOneBy({
+      query: {
+        projectId,
+        userId,
+        ...this.getNotificationMethodQuery(notificationMethod),
+        ruleType,
+      } as any,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (existingRule) {
+      return;
+    }
+
+    const rule: Model = new Model();
+    rule.projectId = projectId;
+    rule.userId = userId;
+    this.applyNotificationMethod(rule, notificationMethod);
+    rule.notifyAfterMinutes = 0;
+    rule.ruleType = ruleType;
+
+    await this.create({
+      data: rule,
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
   @CaptureSpan()
   public async addDefaultNotificationRuleForUser(
     projectId: ObjectID,
@@ -2361,82 +2472,13 @@ export class Service extends DatabaseService<Model> {
       });
     }
 
-    // add default incident rules for user
-    await this.addDefaultIncidentNotificationRuleForUser({
+    await this.addDefaultNotificationRulesForVerifiedMethod({
       projectId,
       userId,
-      userEmail,
-    });
-
-    // add default alert rules for user, just like the incident
-
-    await this.addDefaultAlertNotificationRulesForUser({
-      projectId,
-      userId,
-      userEmail,
-    });
-
-    //check if this rule already exists.
-    const existingRuleOnCall: Model | null = await this.findOneBy({
-      query: {
-        projectId,
-        userId,
-        userEmailId: userEmail.id!,
-        ruleType: NotificationRuleType.WHEN_USER_GOES_ON_CALL,
-      },
-      props: {
-        isRoot: true,
-      },
-    });
-
-    if (!existingRuleOnCall) {
-      // on and off call.
-      const onCallRule: Model = new Model();
-
-      onCallRule.projectId = projectId;
-      onCallRule.userId = userId;
-      onCallRule.userEmailId = userEmail.id!;
-      onCallRule.notifyAfterMinutes = 0;
-      onCallRule.ruleType = NotificationRuleType.WHEN_USER_GOES_ON_CALL;
-
-      await this.create({
-        data: onCallRule,
-        props: {
-          isRoot: true,
-        },
-      });
-    }
-
-    //check if this rule already exists.
-    const existingRuleOffCall: Model | null = await this.findOneBy({
-      query: {
-        projectId,
-        userId,
+      notificationMethod: {
         userEmailId: userEmail.id!,
-        ruleType: NotificationRuleType.WHEN_USER_GOES_OFF_CALL,
-      },
-      props: {
-        isRoot: true,
       },
     });
-
-    if (!existingRuleOffCall) {
-      // on and off call.
-      const offCallRule: Model = new Model();
-
-      offCallRule.projectId = projectId;
-      offCallRule.userId = userId;
-      offCallRule.userEmailId = userEmail.id!;
-      offCallRule.notifyAfterMinutes = 0;
-      offCallRule.ruleType = NotificationRuleType.WHEN_USER_GOES_OFF_CALL;
-
-      await this.create({
-        data: offCallRule,
-        props: {
-          isRoot: true,
-        },
-      });
-    }
   }
 }
 export default new Service();

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

@@ -0,0 +1,142 @@
+import DataToProcess from "../DataToProcess";
+import CompareCriteria from "./CompareCriteria";
+import {
+  CheckOn,
+  CriteriaFilter,
+  FilterType,
+} from "../../../../Types/Monitor/CriteriaFilter";
+import DomainMonitorResponse from "../../../../Types/Monitor/DomainMonitor/DomainMonitorResponse";
+import ProbeMonitorResponse from "../../../../Types/Probe/ProbeMonitorResponse";
+import CaptureSpan from "../../Telemetry/CaptureSpan";
+
+export default class DomainMonitorCriteria {
+  @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 domainResponse: DomainMonitorResponse | undefined =
+      dataToProcess.domainResponse;
+
+    // Check domain expires in days
+    if (input.criteriaFilter.checkOn === CheckOn.DomainExpiresDaysIn) {
+      threshold = CompareCriteria.convertToNumber(threshold);
+
+      if (threshold === null || threshold === undefined) {
+        return null;
+      }
+
+      if (!domainResponse?.expiresDate) {
+        return null;
+      }
+
+      const expiresDate: Date = new Date(domainResponse.expiresDate);
+      const now: Date = new Date();
+      const diffMs: number = expiresDate.getTime() - now.getTime();
+      const diffDays: number = Math.ceil(diffMs / (1000 * 60 * 60 * 24));
+
+      return CompareCriteria.compareCriteriaNumbers({
+        value: diffDays,
+        threshold: threshold as number,
+        criteriaFilter: input.criteriaFilter,
+      });
+    }
+
+    // Check domain registrar
+    if (input.criteriaFilter.checkOn === CheckOn.DomainRegistrar) {
+      if (!domainResponse?.registrar) {
+        return null;
+      }
+
+      return CompareCriteria.compareCriteriaStrings({
+        value: domainResponse.registrar,
+        threshold: String(threshold),
+        criteriaFilter: input.criteriaFilter,
+      });
+    }
+
+    // Check domain name server
+    if (input.criteriaFilter.checkOn === CheckOn.DomainNameServer) {
+      if (
+        !domainResponse?.nameServers ||
+        domainResponse.nameServers.length === 0
+      ) {
+        return null;
+      }
+
+      // Check if any name server matches the criteria
+      for (const nameServer of domainResponse.nameServers) {
+        const result: string | null = CompareCriteria.compareCriteriaStrings({
+          value: nameServer,
+          threshold: String(threshold),
+          criteriaFilter: input.criteriaFilter,
+        });
+
+        if (result) {
+          return `Domain name server: ${result}`;
+        }
+      }
+
+      return null;
+    }
+
+    // Check domain status code
+    if (input.criteriaFilter.checkOn === CheckOn.DomainStatusCode) {
+      if (
+        !domainResponse?.domainStatus ||
+        domainResponse.domainStatus.length === 0
+      ) {
+        return null;
+      }
+
+      // Check if any status matches the criteria
+      for (const status of domainResponse.domainStatus) {
+        const result: string | null = CompareCriteria.compareCriteriaStrings({
+          value: status,
+          threshold: String(threshold),
+          criteriaFilter: input.criteriaFilter,
+        });
+
+        if (result) {
+          return `Domain status: ${result}`;
+        }
+      }
+
+      return null;
+    }
+
+    // Check if domain is expired
+    if (input.criteriaFilter.checkOn === CheckOn.DomainIsExpired) {
+      const isTrue: boolean =
+        input.criteriaFilter.filterType === FilterType.True;
+      const isFalse: boolean =
+        input.criteriaFilter.filterType === FilterType.False;
+
+      if (!domainResponse?.expiresDate) {
+        return null;
+      }
+
+      const expiresDate: Date = new Date(domainResponse.expiresDate);
+      const now: Date = new Date();
+      const isExpired: boolean = expiresDate.getTime() < now.getTime();
+
+      if (isExpired && isTrue) {
+        return `Domain is expired (expired on ${domainResponse.expiresDate}).`;
+      }
+
+      if (!isExpired && isFalse) {
+        return `Domain is not expired (expires on ${domainResponse.expiresDate}).`;
+      }
+
+      return null;
+    }
+
+    return null;
+  }
+}

package/Server/Utils/Monitor/MonitorCriteriaEvaluator.ts

@@ -13,6 +13,7 @@ import TraceMonitorCriteria from "./Criteria/TraceMonitorCriteria";
 import ExceptionMonitorCriteria from "./Criteria/ExceptionMonitorCriteria";
 import SnmpMonitorCriteria from "./Criteria/SnmpMonitorCriteria";
 import DnsMonitorCriteria from "./Criteria/DnsMonitorCriteria";
+import DomainMonitorCriteria from "./Criteria/DomainMonitorCriteria";
 import MonitorCriteriaMessageBuilder from "./MonitorCriteriaMessageBuilder";
 import MonitorCriteriaDataExtractor from "./MonitorCriteriaDataExtractor";
 import MonitorCriteriaMessageFormatter from "./MonitorCriteriaMessageFormatter";
@@ -506,6 +507,18 @@ ${contextBlock}
       }
     }
 
+    if (input.monitor.monitorType === MonitorType.Domain) {
+      const domainMonitorResult: string | null =
+        await DomainMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess: input.dataToProcess,
+          criteriaFilter: input.criteriaFilter,
+        });
+
+      if (domainMonitorResult) {
+        return domainMonitorResult;
+      }
+    }
+
     return null;
   }