@oneuptime/common 10.0.66 → 10.0.68

package/Server/Services/UserNotificationSettingService.ts

@@ -6,10 +6,12 @@ import DatabaseService from "./DatabaseService";
 import MailService from "./MailService";
 import SmsService from "./SmsService";
 import TeamMemberService from "./TeamMemberService";
+import TelegramService from "./TelegramService";
 import UserCallService from "./UserCallService";
 import UserEmailService from "./UserEmailService";
 import UserSmsService from "./UserSmsService";
 import PushNotificationService from "./PushNotificationService";
+import UserTelegramService from "./UserTelegramService";
 import UserWhatsAppService from "./UserWhatsAppService";
 import WhatsAppService from "./WhatsAppService";
 import { CallRequestMessage } from "../../Types/Call/CallRequest";
@@ -21,6 +23,9 @@ import ObjectID from "../../Types/ObjectID";
 import PositiveNumber from "../../Types/PositiveNumber";
 import { SMSMessage } from "../../Types/SMS/SMS";
 import PushNotificationMessage from "../../Types/PushNotification/PushNotificationMessage";
+import TelegramMessage, {
+  TelegramMessagePayload,
+} from "../../Types/Telegram/TelegramMessage";
 import WhatsAppMessage, {
   WhatsAppMessagePayload,
 } from "../../Types/WhatsApp/WhatsAppMessage";
@@ -28,6 +33,7 @@ import UserCall from "../../Models/DatabaseModels/UserCall";
 import UserEmail from "../../Models/DatabaseModels/UserEmail";
 import UserNotificationSetting from "../../Models/DatabaseModels/UserNotificationSetting";
 import UserSMS from "../../Models/DatabaseModels/UserSMS";
+import UserTelegram from "../../Models/DatabaseModels/UserTelegram";
 import UserWhatsApp from "../../Models/DatabaseModels/UserWhatsApp";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import { appendRecipientToWhatsAppMessage } from "../Utils/WhatsAppTemplateUtil";
@@ -47,6 +53,7 @@ export class Service extends DatabaseService<UserNotificationSetting> {
     callRequestMessage: CallRequestMessage;
     pushNotificationMessage: PushNotificationMessage;
     whatsAppMessage: WhatsAppMessagePayload;
+    telegramMessage?: TelegramMessagePayload | undefined;
     incidentId?: ObjectID | undefined;
     alertId?: ObjectID | undefined;
     alertEpisodeId?: ObjectID | undefined;
@@ -79,6 +86,7 @@ export class Service extends DatabaseService<UserNotificationSetting> {
           alertByEmail: true,
           alertBySMS: true,
           alertByWhatsApp: true,
+          alertByTelegram: true,
           alertByCall: true,
           alertByPush: true,
         },
@@ -239,6 +247,112 @@ export class Service extends DatabaseService<UserNotificationSetting> {
         }
       }
 
+      if (notificationSettings.alertByTelegram) {
+        const userTelegrams: Array<UserTelegram> =
+          await UserTelegramService.findBy({
+            query: {
+              userId: data.userId,
+              projectId: data.projectId,
+              isVerified: true,
+            },
+            select: {
+              telegramChatId: true,
+            },
+            limit: LIMIT_PER_PROJECT,
+            skip: 0,
+            props: {
+              isRoot: true,
+            },
+          });
+
+        /*
+         * When the caller did not provide a Telegram-specific message we build a
+         * nicely-formatted HTML body from the email subject + SMS body + optional
+         * URL from the email envelope, with a 🔔 prefix. If they did provide one,
+         * we respect their body/parseMode verbatim.
+         */
+        const callerProvidedTelegramBody: boolean = Boolean(
+          data.telegramMessage?.body,
+        );
+
+        const escapeHtml: (value: string) => string = (
+          value: string,
+        ): string => {
+          return value
+            .replace(/&/g, "&amp;")
+            .replace(/</g, "&lt;")
+            .replace(/>/g, "&gt;");
+        };
+
+        let telegramBody: string = "";
+        let telegramParseMode: TelegramMessage["parseMode"] | undefined =
+          undefined;
+
+        if (callerProvidedTelegramBody) {
+          telegramBody = data.telegramMessage!.body;
+          telegramParseMode = data.telegramMessage!.parseMode;
+        } else {
+          const subject: string = data.emailEnvelope.subject || "";
+          const smsBody: string = data.smsMessage.message || "";
+
+          if (subject || smsBody) {
+            const lines: Array<string> = [];
+            if (subject) {
+              lines.push(`🔔 <b>${escapeHtml(subject)}</b>`);
+            } else {
+              lines.push("🔔 <b>OneUptime notification</b>");
+            }
+            if (smsBody) {
+              lines.push("");
+              lines.push(escapeHtml(smsBody));
+            }
+            telegramBody = lines.join("\n");
+            telegramParseMode = "HTML";
+          }
+        }
+
+        if (!telegramBody) {
+          logger.warn(
+            "Skipping Telegram notification because message body is empty.",
+          );
+        } else {
+          for (const userTelegram of userTelegrams) {
+            if (!userTelegram.telegramChatId) {
+              continue;
+            }
+
+            const telegramMessage: TelegramMessage = {
+              to: userTelegram.telegramChatId,
+              body: telegramBody,
+              parseMode: telegramParseMode,
+              disableWebPagePreview:
+                data.telegramMessage?.disableWebPagePreview ?? true,
+            };
+
+            TelegramService.sendTelegramMessage(telegramMessage, {
+              projectId: data.projectId,
+              incidentId: data.incidentId,
+              alertId: data.alertId,
+              alertEpisodeId: data.alertEpisodeId,
+              incidentEpisodeId: data.incidentEpisodeId,
+              monitorId: data.monitorId,
+              scheduledMaintenanceId: data.scheduledMaintenanceId,
+              statusPageId: data.statusPageId,
+              statusPageAnnouncementId: data.statusPageAnnouncementId,
+              userId: data.userId,
+              teamId: data.teamId,
+              onCallPolicyId: data.onCallPolicyId,
+              onCallPolicyEscalationRuleId: data.onCallPolicyEscalationRuleId,
+              onCallDutyPolicyExecutionLogTimelineId:
+                data.onCallDutyPolicyExecutionLogTimelineId,
+              onCallScheduleId: data.onCallScheduleId,
+            }).catch((err: Error) => {
+              logger.error(err);
+            });
+          }
+        }
+      }
+
       if (notificationSettings.alertByCall) {
         const userCalls: Array<UserCall> = await UserCallService.findBy({
           query: {

package/Server/Services/UserTelegramService.ts

@@ -0,0 +1,140 @@
+import { IsBillingEnabled } from "../EnvironmentConfig";
+import CreateBy from "../Types/Database/CreateBy";
+import DeleteBy from "../Types/Database/DeleteBy";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
+import DatabaseService from "./DatabaseService";
+import ProjectService from "./ProjectService";
+import UserNotificationRuleService from "./UserNotificationRuleService";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import Text from "../../Types/Text";
+import Project from "../../Models/DatabaseModels/Project";
+import Model from "../../Models/DatabaseModels/UserTelegram";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    const itemsToDelete: Array<Model> = await this.findBy({
+      query: deleteBy.query,
+      select: {
+        _id: true,
+        projectId: true,
+      },
+      skip: 0,
+      limit: LIMIT_MAX,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    for (const item of itemsToDelete) {
+      await UserNotificationRuleService.deleteBy({
+        query: {
+          userTelegramId: item.id!,
+          projectId: item.projectId!,
+        },
+        limit: LIMIT_MAX,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+
+    return {
+      deleteBy,
+      carryForward: null,
+    };
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    if (!createBy.props.isRoot && createBy.data.isVerified) {
+      throw new BadDataException("isVerified cannot be set to true");
+    }
+
+    if (!createBy.props.isRoot && createBy.data.telegramChatId) {
+      throw new BadDataException("telegramChatId cannot be set directly");
+    }
+
+    const project: Project | null = await ProjectService.findOneById({
+      id: createBy.data.projectId!,
+      props: {
+        isRoot: true,
+      },
+      select: {
+        enableTelegramNotifications: true,
+        smsOrCallCurrentBalanceInUSDCents: true,
+      },
+    });
+
+    if (!project) {
+      throw new BadDataException("Project not found");
+    }
+
+    if (!project.enableTelegramNotifications) {
+      throw new BadDataException(
+        "Telegram notifications are disabled for this project. Please enable them in Project Settings > Notification Settings.",
+      );
+    }
+
+    if (
+      (project.smsOrCallCurrentBalanceInUSDCents as number) <= 100 &&
+      IsBillingEnabled
+    ) {
+      throw new BadDataException(
+        "Your notification balance is low. Please recharge your balance in Project Settings > Notification Settings.",
+      );
+    }
+
+    return {
+      createBy,
+      carryForward: null,
+    };
+  }
+
+  @CaptureSpan()
+  public async regenerateVerificationCode(itemId: ObjectID): Promise<void> {
+    const item: Model | null = await this.findOneById({
+      id: itemId,
+      props: {
+        isRoot: true,
+      },
+      select: {
+        isVerified: true,
+      },
+    });
+
+    if (!item) {
+      throw new BadDataException(
+        "Item with ID " + itemId.toString() + " not found",
+      );
+    }
+
+    if (item.isVerified) {
+      throw new BadDataException("Telegram account already verified");
+    }
+
+    await this.updateOneById({
+      id: itemId,
+      props: {
+        isRoot: true,
+      },
+      data: {
+        verificationCode: Text.generateRandomNumber(6),
+      },
+    });
+  }
+}
+
+export default new Service();

package/Server/Utils/Monitor/MonitorResource.ts

@@ -280,22 +280,36 @@ export default class MonitorResourceUtil {
 
         logger.debug(dataToProcess);
 
-        await MonitorService.updateOneById({
-          id: monitor.id!,
-          data: {
-            serverMonitorRequestReceivedAt:
-              serverMonitorResponse.requestReceivedAt!,
-            serverMonitorResponse,
-          },
-          props: {
-            isRoot: true,
-            ignoreHooks: true,
-          },
-        });
+        /*
+         * Skip persistence when this evaluation originated from the
+         * CheckOnlineStatus cron (onlyCheckRequestReceivedAt=true). The cron
+         * re-evaluates using the already-stale value read from the DB and has
+         * no new heartbeat data to persist — writing it back would race with
+         * (and overwrite) the ingest path's fresh heartbeat update, causing
+         * the monitor to flap between Online and Offline every minute.
+         */
+        if (!serverMonitorResponse.onlyCheckRequestReceivedAt) {
+          await MonitorService.updateOneById({
+            id: monitor.id!,
+            data: {
+              serverMonitorRequestReceivedAt:
+                serverMonitorResponse.requestReceivedAt!,
+              serverMonitorResponse,
+            },
+            props: {
+              isRoot: true,
+              ignoreHooks: true,
+            },
+          });
 
-        logger.debug(
-          `${dataToProcess.monitorId.toString()} - Monitor Server Response Updated`,
-        );
+          logger.debug(
+            `${dataToProcess.monitorId.toString()} - Monitor Server Response Updated`,
+          );
+        } else {
+          logger.debug(
+            `${dataToProcess.monitorId.toString()} - Skipping Monitor Server Response persist (cron re-evaluation).`,
+          );
+        }
       }
 
       if (incomingMonitorRequest) {

package/Server/Utils/Monitor/MonitorTemplateUtil.ts

@@ -183,16 +183,10 @@ export default class MonitorTemplateUtil {
         }
       }
 
-      if (
-        data.monitorType === MonitorType.SyntheticMonitor ||
-        data.monitorType === MonitorType.CustomJavaScriptCode
-      ) {
+      if (data.monitorType === MonitorType.CustomJavaScriptCode) {
         const customCodeResponse: CustomCodeMonitorResponse | undefined = (
           data.dataToProcess as ProbeMonitorResponse
         ).customCodeMonitorResponse;
-        const syntheticResponse: SyntheticMonitorResponse[] | undefined = (
-          data.dataToProcess as ProbeMonitorResponse
-        ).syntheticMonitorResponse;
 
         storageMap = {
           executionTimeInMs: customCodeResponse?.executionTimeInMS,
@@ -202,16 +196,35 @@ export default class MonitorTemplateUtil {
           failureCause: (data.dataToProcess as ProbeMonitorResponse)
             .failureCause,
         } as JSONObject;
+      }
 
-        // Add synthetic monitor specific fields if available
-        if (syntheticResponse && syntheticResponse.length > 0) {
-          const firstResponse: SyntheticMonitorResponse = syntheticResponse[0]!;
-          if (firstResponse) {
-            storageMap["screenshots"] = firstResponse.screenshots;
-            storageMap["browserType"] = firstResponse.browserType;
-            storageMap["screenSizeType"] = firstResponse.screenSizeType;
-          }
-        }
+      if (data.monitorType === MonitorType.SyntheticMonitor) {
+        const syntheticResponse: SyntheticMonitorResponse[] | undefined = (
+          data.dataToProcess as ProbeMonitorResponse
+        ).syntheticMonitorResponse;
+
+        /*
+         * Synthetic monitors run across multiple browser / screen-size combinations.
+         * Each run is exposed through the syntheticResponses array — use
+         * {{syntheticResponses[i].*}} or {{#each syntheticResponses}} in templates.
+         */
+        storageMap = {
+          syntheticResponses: (syntheticResponse || []).map(
+            (response: SyntheticMonitorResponse) => {
+              return {
+                executionTimeInMs: response.executionTimeInMS,
+                result: response.result,
+                scriptError: response.scriptError,
+                logMessages: response.logMessages || [],
+                screenshots: response.screenshots,
+                browserType: response.browserType,
+                screenSizeType: response.screenSizeType,
+              };
+            },
+          ),
+          failureCause: (data.dataToProcess as ProbeMonitorResponse)
+            .failureCause,
+        } as JSONObject;
       }
 
       if (data.monitorType === MonitorType.SNMP) {

package/Tests/Types/Date.test.ts

@@ -1,5 +1,6 @@
 import OneUptimeDate from "../../Types/Date";
 import PositiveNumber from "../../Types/PositiveNumber";
+import Timezone from "../../Types/Timezone";
 import moment, { isMoment } from "moment";
 
 describe("class OneUptimeDate", () => {
@@ -92,4 +93,161 @@ describe("class OneUptimeDate", () => {
       OneUptimeDate.fromString("2026-04-01 14:45:31.414000000").toISOString(),
     ).toBe("2026-04-01T14:45:31.414Z");
   });
+
+  describe("getZoneAbbrByTimezone (DST awareness)", () => {
+    test("returns EST for America/New_York on a winter date", () => {
+      const winterDate: Date = new Date("2026-01-15T12:00:00Z");
+      expect(
+        OneUptimeDate.getZoneAbbrByTimezone(
+          Timezone.AmericaNew_York,
+          winterDate,
+        ),
+      ).toBe("EST");
+    });
+
+    test("returns EDT for America/New_York on a summer date", () => {
+      const summerDate: Date = new Date("2026-07-15T12:00:00Z");
+      expect(
+        OneUptimeDate.getZoneAbbrByTimezone(
+          Timezone.AmericaNew_York,
+          summerDate,
+        ),
+      ).toBe("EDT");
+    });
+
+    test("returns PST for America/Los_Angeles on a winter date", () => {
+      const winterDate: Date = new Date("2026-01-15T12:00:00Z");
+      expect(
+        OneUptimeDate.getZoneAbbrByTimezone(
+          Timezone.AmericaLos_Angeles,
+          winterDate,
+        ),
+      ).toBe("PST");
+    });
+
+    test("returns PDT for America/Los_Angeles on a summer date", () => {
+      const summerDate: Date = new Date("2026-07-15T12:00:00Z");
+      expect(
+        OneUptimeDate.getZoneAbbrByTimezone(
+          Timezone.AmericaLos_Angeles,
+          summerDate,
+        ),
+      ).toBe("PDT");
+    });
+
+    test("returns UTC for UTC regardless of date", () => {
+      const winterDate: Date = new Date("2026-01-15T12:00:00Z");
+      const summerDate: Date = new Date("2026-07-15T12:00:00Z");
+      expect(
+        OneUptimeDate.getZoneAbbrByTimezone(Timezone.UTC, winterDate),
+      ).toBe("UTC");
+      expect(
+        OneUptimeDate.getZoneAbbrByTimezone(Timezone.UTC, summerDate),
+      ).toBe("UTC");
+    });
+
+    test("returns IST for Asia/Kolkata year-round (no DST)", () => {
+      const winterDate: Date = new Date("2026-01-15T12:00:00Z");
+      const summerDate: Date = new Date("2026-07-15T12:00:00Z");
+      expect(
+        OneUptimeDate.getZoneAbbrByTimezone(Timezone.AsiaKolkata, winterDate),
+      ).toBe("IST");
+      expect(
+        OneUptimeDate.getZoneAbbrByTimezone(Timezone.AsiaKolkata, summerDate),
+      ).toBe("IST");
+    });
+
+    test("returns correct abbreviation right after US DST spring-forward", () => {
+      // US DST begins 2026-03-08 at 02:00 local -> springs to 03:00 EDT.
+      const beforeDst: Date = new Date("2026-03-08T06:00:00Z"); // 01:00 EST
+      const afterDst: Date = new Date("2026-03-08T08:00:00Z"); // 04:00 EDT
+      expect(
+        OneUptimeDate.getZoneAbbrByTimezone(
+          Timezone.AmericaNew_York,
+          beforeDst,
+        ),
+      ).toBe("EST");
+      expect(
+        OneUptimeDate.getZoneAbbrByTimezone(Timezone.AmericaNew_York, afterDst),
+      ).toBe("EDT");
+    });
+
+    test("accepts an ISO date string", () => {
+      expect(
+        OneUptimeDate.getZoneAbbrByTimezone(
+          Timezone.AmericaNew_York,
+          "2026-01-15T12:00:00Z",
+        ),
+      ).toBe("EST");
+      expect(
+        OneUptimeDate.getZoneAbbrByTimezone(
+          Timezone.AmericaNew_York,
+          "2026-07-15T12:00:00Z",
+        ),
+      ).toBe("EDT");
+    });
+
+    test("falls back to current date when no date is passed (backward compat)", () => {
+      const abbr: string = OneUptimeDate.getZoneAbbrByTimezone(Timezone.UTC);
+      expect(abbr).toBe("UTC");
+    });
+  });
+
+  describe("getDateAsFormattedArrayInMultipleTimezones (DST awareness)", () => {
+    test("shows EST for a winter event in America/New_York", () => {
+      const result: Array<string> =
+        OneUptimeDate.getDateAsFormattedArrayInMultipleTimezones({
+          date: new Date("2026-01-15T17:00:00Z"),
+          timezones: [Timezone.AmericaNew_York],
+          use12HourFormat: true,
+        });
+      expect(result).toHaveLength(1);
+      expect(result[0]).toContain("EST");
+      expect(result[0]).not.toContain("EDT");
+      // 17:00 UTC in winter EST (UTC-5) = 12:00 PM
+      expect(result[0]).toContain("12:00 PM");
+    });
+
+    test("shows EDT for a summer event in America/New_York", () => {
+      const result: Array<string> =
+        OneUptimeDate.getDateAsFormattedArrayInMultipleTimezones({
+          date: new Date("2026-07-15T17:00:00Z"),
+          timezones: [Timezone.AmericaNew_York],
+          use12HourFormat: true,
+        });
+      expect(result).toHaveLength(1);
+      expect(result[0]).toContain("EDT");
+      expect(result[0]).not.toContain("EST");
+      // 17:00 UTC in summer EDT (UTC-4) = 01:00 PM
+      expect(result[0]).toContain("01:00 PM");
+    });
+
+    test("picks the correct abbreviation per-timezone for the same event", () => {
+      // A winter event in multiple zones: NY should say EST, LA should say PST, UTC stays UTC.
+      const result: Array<string> =
+        OneUptimeDate.getDateAsFormattedArrayInMultipleTimezones({
+          date: new Date("2026-01-15T17:00:00Z"),
+          timezones: [
+            Timezone.UTC,
+            Timezone.AmericaNew_York,
+            Timezone.AmericaLos_Angeles,
+          ],
+          use12HourFormat: true,
+        });
+      expect(result[0]).toContain("UTC");
+      expect(result[1]).toContain("EST");
+      expect(result[2]).toContain("PST");
+    });
+
+    test("omits the abbreviation when onlyShowDate is true", () => {
+      const result: Array<string> =
+        OneUptimeDate.getDateAsFormattedArrayInMultipleTimezones({
+          date: new Date("2026-07-15T17:00:00Z"),
+          timezones: [Timezone.AmericaNew_York],
+          onlyShowDate: true,
+        });
+      expect(result[0]).not.toContain("EDT");
+      expect(result[0]).not.toContain("EST");
+    });
+  });
 });

package/Types/AnalyticsDatabase/AnalyticsTableName.ts

@@ -6,6 +6,7 @@ enum AnalyticsTableName {
   MonitorLog = "MonitorLogV2",
   Profile = "ProfileItemV2",
   ProfileSample = "ProfileSampleItemV2",
+  AuditLog = "AuditLogV1",
 }
 
 export default AnalyticsTableName;

package/Types/AuditLog/AuditLogAction.ts

@@ -0,0 +1,7 @@
+enum AuditLogAction {
+  Create = "Create",
+  Update = "Update",
+  Delete = "Delete",
+}
+
+export default AuditLogAction;

package/Types/BaseDatabase/EnableAuditLogOn.ts

@@ -0,0 +1,5 @@
+export default interface EnableAuditLogOn {
+  create?: boolean | undefined;
+  update?: boolean | undefined;
+  delete?: boolean | undefined;
+}

package/Types/Database/EnableAuditLog.ts

@@ -0,0 +1,18 @@
+import EnableAuditLogOn from "../BaseDatabase/EnableAuditLogOn";
+import GenericFunction from "../GenericFunction";
+
+export default (
+  enableAuditLogOn: EnableAuditLogOn = {
+    create: true,
+    update: true,
+    delete: true,
+  },
+) => {
+  return (ctr: GenericFunction) => {
+    ctr.prototype.enableAuditLogOn = {
+      create: enableAuditLogOn.create ?? true,
+      update: enableAuditLogOn.update ?? true,
+      delete: enableAuditLogOn.delete ?? true,
+    };
+  };
+};

package/Types/Date.ts

@@ -1406,7 +1406,7 @@ export default class OneUptimeDate {
           " " +
           (onlyShowDate
             ? ""
-            : this.getZoneAbbrByTimezone(timezones[i] as Timezone)),
+            : this.getZoneAbbrByTimezone(timezones[i] as Timezone, date)),
       );
     }
 
@@ -1497,8 +1497,17 @@ export default class OneUptimeDate {
     return this.getZoneAbbrByTimezone(this.getCurrentTimezone());
   }
 
-  public static getZoneAbbrByTimezone(timezone: Timezone): string {
-    let zoneAbbr: string = moment.tz(timezone).zoneAbbr();
+  public static getZoneAbbrByTimezone(
+    timezone: Timezone,
+    date?: string | Date | undefined,
+  ): string {
+    /*
+     * Pass the reference date into moment so the abbreviation reflects DST
+     * at that date (e.g. EST in winter, EDT in summer) rather than "now".
+     */
+    let zoneAbbr: string = date
+      ? moment(this.fromString(date)).tz(timezone).zoneAbbr()
+      : moment.tz(timezone).zoneAbbr();
 
     if (zoneAbbr.startsWith("+") || zoneAbbr.startsWith("-")) {
       zoneAbbr = "GMT" + zoneAbbr;

package/Types/Icon/IconProp.ts

@@ -141,6 +141,7 @@ enum IconProp {
   SquareStack3D = "SquareStack3D",
   ExclaimationCircle = "ExclaimationCircle",
   WhatsApp = "WhatsApp",
+  Telegram = "Telegram",
   Brain = "Brain",
   FlowDiagram = "FlowDiagram",
   GitHub = "GitHub",