@oneuptime/common 10.0.66 → 10.0.68

package/Server/Services/Index.ts

@@ -36,6 +36,7 @@ import LabelService from "./LabelService";
 import KubernetesClusterService from "./KubernetesClusterService";
 import DockerHostService from "./DockerHostService";
 import LlmProviderService from "./LlmProviderService";
+import AuditLogService from "./AuditLogService";
 import LogService from "./LogService";
 import MailService from "./MailService";
 import MetricService from "./MetricService";
@@ -104,7 +105,9 @@ import ShortLinkService from "./ShortLinkService";
 // SMS Log Service
 import SmsLogService from "./SmsLogService";
 import WhatsAppLogService from "./WhatsAppLogService";
+import TelegramLogService from "./TelegramLogService";
 import SmsService from "./SmsService";
+import TelegramService from "./TelegramService";
 import SpanService from "./SpanService";
 import StatusPageAnnouncementService from "./StatusPageAnnouncementService";
 import StatusPageAnnouncementTemplateService from "./StatusPageAnnouncementTemplateService";
@@ -146,6 +149,7 @@ import UserWebAuthnService from "./UserWebAuthnService";
 import UserSmsService from "./UserSmsService";
 import UserIncomingCallNumberService from "./UserIncomingCallNumberService";
 import UserWhatsAppService from "./UserWhatsAppService";
+import UserTelegramService from "./UserTelegramService";
 import WorkflowLogService from "./WorkflowLogService";
 // Workflows.
 import WorkflowService from "./WorkflowService";
@@ -307,7 +311,9 @@ const services: Array<BaseService> = [
   ShortLinkService,
   SmsLogService,
   WhatsAppLogService,
+  TelegramLogService,
   SmsService,
+  TelegramService,
 
   StatusPageAnnouncementService,
   StatusPageAnnouncementTemplateService,
@@ -346,6 +352,7 @@ const services: Array<BaseService> = [
   UserSmsService,
   UserIncomingCallNumberService,
   UserWhatsAppService,
+  UserTelegramService,
   UserTotpAuthService,
   UserWebAuthnService,
 
@@ -441,6 +448,7 @@ export const AnalyticsServices: Array<
   MonitorLogService,
   ProfileService,
   ProfileSampleService,
+  AuditLogService,
 ];
 
 export default services;

package/Server/Services/TelegramLogService.ts

@@ -0,0 +1,15 @@
+import { IsBillingEnabled } from "../EnvironmentConfig";
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/TelegramLog";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 3);
+    }
+  }
+}
+
+export default new Service();

package/Server/Services/TelegramService.ts

@@ -0,0 +1,139 @@
+import { AppApiHostname } from "../EnvironmentConfig";
+import ClusterKeyAuthorization from "../Middleware/ClusterKeyAuthorization";
+import BaseService from "./BaseService";
+import EmptyResponseData from "../../Types/API/EmptyResponse";
+import HTTPResponse from "../../Types/API/HTTPResponse";
+import Protocol from "../../Types/API/Protocol";
+import Route from "../../Types/API/Route";
+import URL from "../../Types/API/URL";
+import { JSONObject } from "../../Types/JSON";
+import ObjectID from "../../Types/ObjectID";
+import TelegramMessage from "../../Types/Telegram/TelegramMessage";
+import API from "../../Utils/API";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+
+export class TelegramService extends BaseService {
+  public constructor() {
+    super();
+  }
+
+  @CaptureSpan()
+  public async sendTelegramMessage(
+    message: TelegramMessage,
+    options: {
+      projectId?: ObjectID | undefined;
+      isSensitive?: boolean | undefined;
+      userOnCallLogTimelineId?: ObjectID | undefined;
+      incidentId?: ObjectID | undefined;
+      alertId?: ObjectID | undefined;
+      alertEpisodeId?: ObjectID | undefined;
+      incidentEpisodeId?: ObjectID | undefined;
+      monitorId?: ObjectID | undefined;
+      scheduledMaintenanceId?: ObjectID | undefined;
+      statusPageId?: ObjectID | undefined;
+      statusPageAnnouncementId?: ObjectID | undefined;
+      userId?: ObjectID | undefined;
+      onCallPolicyId?: ObjectID | undefined;
+      onCallPolicyEscalationRuleId?: ObjectID | undefined;
+      onCallDutyPolicyExecutionLogTimelineId?: ObjectID | undefined;
+      onCallScheduleId?: ObjectID | undefined;
+      teamId?: ObjectID | undefined;
+    } = {},
+  ): Promise<HTTPResponse<EmptyResponseData>> {
+    const body: JSONObject = {
+      to: message.to,
+      body: message.body,
+    };
+
+    if (message.parseMode) {
+      body["parseMode"] = message.parseMode;
+    }
+
+    if (message.disableWebPagePreview !== undefined) {
+      body["disableWebPagePreview"] = message.disableWebPagePreview;
+    }
+
+    if (options.projectId) {
+      body["projectId"] = options.projectId.toString();
+    }
+
+    if (options.isSensitive !== undefined) {
+      body["isSensitive"] = options.isSensitive;
+    }
+
+    if (options.userOnCallLogTimelineId) {
+      body["userOnCallLogTimelineId"] =
+        options.userOnCallLogTimelineId.toString();
+    }
+
+    if (options.incidentId) {
+      body["incidentId"] = options.incidentId.toString();
+    }
+
+    if (options.alertId) {
+      body["alertId"] = options.alertId.toString();
+    }
+
+    if (options.alertEpisodeId) {
+      body["alertEpisodeId"] = options.alertEpisodeId.toString();
+    }
+
+    if (options.monitorId) {
+      body["monitorId"] = options.monitorId.toString();
+    }
+
+    if (options.scheduledMaintenanceId) {
+      body["scheduledMaintenanceId"] =
+        options.scheduledMaintenanceId.toString();
+    }
+
+    if (options.statusPageId) {
+      body["statusPageId"] = options.statusPageId.toString();
+    }
+
+    if (options.statusPageAnnouncementId) {
+      body["statusPageAnnouncementId"] =
+        options.statusPageAnnouncementId.toString();
+    }
+
+    if (options.userId) {
+      body["userId"] = options.userId.toString();
+    }
+
+    if (options.onCallPolicyId) {
+      body["onCallPolicyId"] = options.onCallPolicyId.toString();
+    }
+
+    if (options.onCallPolicyEscalationRuleId) {
+      body["onCallPolicyEscalationRuleId"] =
+        options.onCallPolicyEscalationRuleId.toString();
+    }
+
+    if (options.onCallDutyPolicyExecutionLogTimelineId) {
+      body["onCallDutyPolicyExecutionLogTimelineId"] =
+        options.onCallDutyPolicyExecutionLogTimelineId.toString();
+    }
+
+    if (options.onCallScheduleId) {
+      body["onCallScheduleId"] = options.onCallScheduleId.toString();
+    }
+
+    if (options.teamId) {
+      body["teamId"] = options.teamId.toString();
+    }
+
+    return await API.post<EmptyResponseData>({
+      url: new URL(
+        Protocol.HTTP,
+        AppApiHostname,
+        new Route("/api/notification/telegram/send"),
+      ),
+      data: body,
+      headers: {
+        ...ClusterKeyAuthorization.getClusterKeyHeaders(),
+      },
+    });
+  }
+}
+
+export default new TelegramService();

package/Server/Services/UserNotificationRuleService.ts

@@ -9,6 +9,7 @@ import IncidentSeverityService from "./IncidentSeverityService";
 import MailService from "./MailService";
 import ShortLinkService from "./ShortLinkService";
 import SmsService from "./SmsService";
+import TelegramService from "./TelegramService";
 import WhatsAppService from "./WhatsAppService";
 import UserEmailService from "./UserEmailService";
 import UserOnCallLogService from "./UserOnCallLogService";
@@ -32,6 +33,7 @@ import ObjectID from "../../Types/ObjectID";
 import PushDeviceType from "../../Types/PushNotification/PushDeviceType";
 import Phone from "../../Types/Phone";
 import SMS from "../../Types/SMS/SMS";
+import TelegramMessage from "../../Types/Telegram/TelegramMessage";
 import WhatsAppMessage from "../../Types/WhatsApp/WhatsAppMessage";
 import {
   renderWhatsAppTemplate,
@@ -74,6 +76,7 @@ export interface NotificationMethodDescriptor {
   userSmsId?: ObjectID;
   userCallId?: ObjectID;
   userWhatsAppId?: ObjectID;
+  userTelegramId?: ObjectID;
   userPushId?: ObjectID;
 }
 
@@ -165,6 +168,11 @@ export class Service extends DatabaseService<Model> {
           phone: true,
           isVerified: true,
         },
+        userTelegram: {
+          telegramChatId: true,
+          telegramUserHandle: true,
+          isVerified: true,
+        },
         userEmail: {
           email: true,
           isVerified: true,
@@ -896,6 +904,184 @@ export class Service extends DatabaseService<Model> {
       });
     }
 
+    // send Telegram.
+    if (
+      notificationRuleItem.userTelegram?.telegramChatId &&
+      notificationRuleItem.userTelegram?.isVerified
+    ) {
+      if (
+        options.userNotificationEventType ===
+          UserNotificationEventType.AlertCreated &&
+        alert
+      ) {
+        logTimelineItem.status = UserNotificationStatus.Sending;
+        logTimelineItem.statusMessage = `Sending Telegram message.`;
+        logTimelineItem.userTelegramId = notificationRuleItem.userTelegram.id!;
+
+        const updatedLog: UserOnCallLogTimeline =
+          await UserOnCallLogTimelineService.create({
+            data: logTimelineItem,
+            props: {
+              isRoot: true,
+            },
+          });
+
+        const telegramMessage: TelegramMessage = {
+          to: notificationRuleItem.userTelegram.telegramChatId,
+          body: await this.generateTelegramBodyForAlertCreated(
+            alert,
+            updatedLog.id!,
+          ),
+          parseMode: "HTML",
+          disableWebPagePreview: true,
+        };
+
+        TelegramService.sendTelegramMessage(telegramMessage, {
+          projectId: alert.projectId,
+          alertId: alert.id!,
+          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 Telegram message.",
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+        });
+      }
+
+      if (
+        options.userNotificationEventType ===
+          UserNotificationEventType.IncidentCreated &&
+        incident
+      ) {
+        logTimelineItem.status = UserNotificationStatus.Sending;
+        logTimelineItem.statusMessage = `Sending Telegram message.`;
+        logTimelineItem.userTelegramId = notificationRuleItem.userTelegram.id!;
+
+        const updatedLog: UserOnCallLogTimeline =
+          await UserOnCallLogTimelineService.create({
+            data: logTimelineItem,
+            props: {
+              isRoot: true,
+            },
+          });
+
+        const telegramMessage: TelegramMessage = {
+          to: notificationRuleItem.userTelegram.telegramChatId,
+          body: await this.generateTelegramBodyForIncidentCreated(
+            incident,
+            updatedLog.id!,
+          ),
+          parseMode: "HTML",
+          disableWebPagePreview: true,
+        };
+
+        TelegramService.sendTelegramMessage(telegramMessage, {
+          projectId: incident.projectId,
+          incidentId: incident.id!,
+          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 Telegram message.",
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+        });
+      }
+
+      if (
+        options.userNotificationEventType ===
+          UserNotificationEventType.AlertEpisodeCreated &&
+        alertEpisode
+      ) {
+        logTimelineItem.status = UserNotificationStatus.Sending;
+        logTimelineItem.statusMessage = `Sending Telegram message.`;
+        logTimelineItem.userTelegramId = notificationRuleItem.userTelegram.id!;
+
+        const updatedLog: UserOnCallLogTimeline =
+          await UserOnCallLogTimelineService.create({
+            data: logTimelineItem,
+            props: {
+              isRoot: true,
+            },
+          });
+
+        const telegramMessage: TelegramMessage = {
+          to: notificationRuleItem.userTelegram.telegramChatId,
+          body: await this.generateTelegramBodyForAlertEpisodeCreated(
+            alertEpisode,
+            updatedLog.id!,
+          ),
+          parseMode: "HTML",
+          disableWebPagePreview: true,
+        };
+
+        TelegramService.sendTelegramMessage(telegramMessage, {
+          projectId: alertEpisode.projectId,
+          alertEpisodeId: alertEpisode.id!,
+          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 Telegram message.",
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+        });
+      }
+    }
+
+    if (
+      notificationRuleItem.userTelegram &&
+      !notificationRuleItem.userTelegram?.isVerified
+    ) {
+      logTimelineItem.status = UserNotificationStatus.Error;
+      logTimelineItem.statusMessage = `Telegram message not sent because the Telegram account is not verified.`;
+      logTimelineItem.userTelegramId = notificationRuleItem.userTelegram.id!;
+
+      await UserOnCallLogTimelineService.create({
+        data: logTimelineItem,
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+
     // send call.
     if (
       notificationRuleItem.userCall?.phone &&
@@ -1680,6 +1866,161 @@ export class Service extends DatabaseService<Model> {
     return sms;
   }
 
+  private async buildOnCallAcknowledgeShortUrl(
+    userOnCallLogTimelineId: ObjectID,
+  ): Promise<URL> {
+    const host: Hostname = await DatabaseConfig.getHost();
+    const httpProtocol: Protocol = await DatabaseConfig.getHttpProtocol();
+
+    const shortUrl: ShortLink = await ShortLinkService.saveShortLinkFor(
+      new URL(
+        httpProtocol,
+        host,
+        new Route(AppApiRoute.toString())
+          .addRoute(new UserOnCallLogTimeline().crudApiPath!)
+          .addRoute("/acknowledge-page/" + userOnCallLogTimelineId.toString()),
+      ),
+    );
+    return await ShortLinkService.getShortenedUrl(shortUrl);
+  }
+
+  /*
+   * Telegram's HTML parse_mode supports <b>, <i>, <a>, <code>. Only <, >, and &
+   * need escaping inside those tags' text content.
+   */
+  private escapeTelegramHtml(value: string): string {
+    return value
+      .replace(/&/g, "&amp;")
+      .replace(/</g, "&lt;")
+      .replace(/>/g, "&gt;");
+  }
+
+  @CaptureSpan()
+  public async generateTelegramBodyForAlertCreated(
+    alert: Alert,
+    userOnCallLogTimelineId: ObjectID,
+  ): Promise<string> {
+    const ackUrl: URL = await this.buildOnCallAcknowledgeShortUrl(
+      userOnCallLogTimelineId,
+    );
+
+    const alertIdentifier: string =
+      alert.alertNumber !== undefined
+        ? `${alert.alertNumberWithPrefix || "#" + alert.alertNumber} — ${alert.title || "Alert"}`
+        : alert.title || "Alert";
+
+    const lines: Array<string> = [
+      "🚨 <b>New alert assigned to you</b>",
+      "",
+      `📋 <b>${this.escapeTelegramHtml(alertIdentifier)}</b>`,
+      "",
+      "👤 You're getting this because you're on call.",
+    ];
+
+    if (alert.projectId && alert.id) {
+      const dashboardUrl: URL = await AlertService.getAlertLinkInDashboard(
+        alert.projectId,
+        alert.id,
+      );
+      lines.push(
+        "",
+        `🔎 <a href="${this.escapeTelegramHtml(dashboardUrl.toString())}">View alert in OneUptime</a>`,
+      );
+    }
+
+    lines.push(
+      "",
+      `✅ <a href="${this.escapeTelegramHtml(ackUrl.toString())}">Tap to acknowledge</a>`,
+    );
+
+    return lines.join("\n");
+  }
+
+  @CaptureSpan()
+  public async generateTelegramBodyForIncidentCreated(
+    incident: Incident,
+    userOnCallLogTimelineId: ObjectID,
+  ): Promise<string> {
+    const ackUrl: URL = await this.buildOnCallAcknowledgeShortUrl(
+      userOnCallLogTimelineId,
+    );
+
+    const incidentIdentifier: string =
+      incident.incidentNumber !== undefined
+        ? `${incident.incidentNumberWithPrefix || "#" + incident.incidentNumber} — ${incident.title || "Incident"}`
+        : incident.title || "Incident";
+
+    const lines: Array<string> = [
+      "🔥 <b>New incident assigned to you</b>",
+      "",
+      `📋 <b>${this.escapeTelegramHtml(incidentIdentifier)}</b>`,
+      "",
+      "👤 You're getting this because you're on call.",
+    ];
+
+    if (incident.projectId && incident.id) {
+      const dashboardUrl: URL =
+        await IncidentService.getIncidentLinkInDashboard(
+          incident.projectId,
+          incident.id,
+        );
+      lines.push(
+        "",
+        `🔎 <a href="${this.escapeTelegramHtml(dashboardUrl.toString())}">View incident in OneUptime</a>`,
+      );
+    }
+
+    lines.push(
+      "",
+      `✅ <a href="${this.escapeTelegramHtml(ackUrl.toString())}">Tap to acknowledge</a>`,
+    );
+
+    return lines.join("\n");
+  }
+
+  @CaptureSpan()
+  public async generateTelegramBodyForAlertEpisodeCreated(
+    alertEpisode: AlertEpisode,
+    userOnCallLogTimelineId: ObjectID,
+  ): Promise<string> {
+    const ackUrl: URL = await this.buildOnCallAcknowledgeShortUrl(
+      userOnCallLogTimelineId,
+    );
+
+    const episodeIdentifier: string = alertEpisode.episodeNumberWithPrefix
+      ? `${alertEpisode.episodeNumberWithPrefix} — ${alertEpisode.title || "Alert Episode"}`
+      : alertEpisode.episodeNumber !== undefined
+        ? `#${alertEpisode.episodeNumber} — ${alertEpisode.title || "Alert Episode"}`
+        : alertEpisode.title || "Alert Episode";
+
+    const lines: Array<string> = [
+      "🔔 <b>New alert episode assigned to you</b>",
+      "",
+      `📋 <b>${this.escapeTelegramHtml(episodeIdentifier)}</b>`,
+      "",
+      "👤 You're getting this because you're on call.",
+    ];
+
+    if (alertEpisode.projectId && alertEpisode.id) {
+      const dashboardUrl: URL =
+        await AlertEpisodeService.getEpisodeLinkInDashboard(
+          alertEpisode.projectId,
+          alertEpisode.id,
+        );
+      lines.push(
+        "",
+        `🔎 <a href="${this.escapeTelegramHtml(dashboardUrl.toString())}">View alert episode in OneUptime</a>`,
+      );
+    }
+
+    lines.push(
+      "",
+      `✅ <a href="${this.escapeTelegramHtml(ackUrl.toString())}">Tap to acknowledge</a>`,
+    );
+
+    return lines.join("\n");
+  }
+
   @CaptureSpan()
   public async generateWhatsAppTemplateForAlertCreated(
     to: Phone,
@@ -2288,12 +2629,14 @@ export class Service extends DatabaseService<Model> {
       !createBy.data.userSmsId &&
       !createBy.data.userWhatsApp &&
       !createBy.data.userWhatsAppId &&
+      !createBy.data.userTelegram &&
+      !createBy.data.userTelegramId &&
       !createBy.data.userEmailId &&
       !createBy.data.userPushId &&
       !createBy.data.userPush
     ) {
       throw new BadDataException(
-        "Call, SMS, WhatsApp, Email, or Push notification is required",
+        "Call, SMS, WhatsApp, Telegram, Email, or Push notification is required",
       );
     }
 
@@ -2355,6 +2698,9 @@ export class Service extends DatabaseService<Model> {
     if (descriptor.userWhatsAppId) {
       rule.userWhatsAppId = descriptor.userWhatsAppId;
     }
+    if (descriptor.userTelegramId) {
+      rule.userTelegramId = descriptor.userTelegramId;
+    }
     if (descriptor.userPushId) {
       rule.userPushId = descriptor.userPushId;
     }
@@ -2376,6 +2722,9 @@ export class Service extends DatabaseService<Model> {
     if (descriptor.userWhatsAppId) {
       query["userWhatsAppId"] = descriptor.userWhatsAppId;
     }
+    if (descriptor.userTelegramId) {
+      query["userTelegramId"] = descriptor.userTelegramId;
+    }
     if (descriptor.userPushId) {
       query["userPushId"] = descriptor.userPushId;
     }