@oneuptime/common 10.0.65 → 10.0.67

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/Criteria/CompareCriteria.ts

@@ -389,6 +389,8 @@ export default class CompareCriteria {
     value: Array<number> | number;
     threshold: number;
     criteriaFilter: CriteriaFilter;
+    metricDisplayName?: string | undefined;
+    unit?: string | undefined;
   }): string | null {
     if (data.value === null || data.value === undefined) {
       return null;
@@ -412,6 +414,8 @@ export default class CompareCriteria {
           values: data.value,
           threshold: data.threshold as number,
           criteriaFilter: data.criteriaFilter,
+          metricDisplayName: data.metricDisplayName,
+          unit: data.unit,
         });
       }
 
@@ -432,6 +436,8 @@ export default class CompareCriteria {
           values: data.value,
           threshold: data.threshold as number,
           criteriaFilter: data.criteriaFilter,
+          metricDisplayName: data.metricDisplayName,
+          unit: data.unit,
         });
       }
 
@@ -452,6 +458,8 @@ export default class CompareCriteria {
           values: data.value,
           threshold: data.threshold as number,
           criteriaFilter: data.criteriaFilter,
+          metricDisplayName: data.metricDisplayName,
+          unit: data.unit,
         });
       }
 
@@ -472,6 +480,8 @@ export default class CompareCriteria {
           values: data.value,
           threshold: data.threshold as number,
           criteriaFilter: data.criteriaFilter,
+          metricDisplayName: data.metricDisplayName,
+          unit: data.unit,
         });
       }
 
@@ -492,6 +502,8 @@ export default class CompareCriteria {
           values: data.value,
           threshold: data.threshold as number,
           criteriaFilter: data.criteriaFilter,
+          metricDisplayName: data.metricDisplayName,
+          unit: data.unit,
         });
       }
 
@@ -512,6 +524,8 @@ export default class CompareCriteria {
           values: data.value,
           threshold: data.threshold as number,
           criteriaFilter: data.criteriaFilter,
+          metricDisplayName: data.metricDisplayName,
+          unit: data.unit,
         });
       }
 
@@ -526,6 +540,8 @@ export default class CompareCriteria {
     values: Array<number | boolean> | number | boolean | string;
     threshold: number | string | boolean;
     criteriaFilter: CriteriaFilter;
+    metricDisplayName?: string | undefined;
+    unit?: string | undefined;
   }): string {
     // CPU Percent over the last 5 minutes is 10 which is less than the threshold of 20
     let message: string = "";
@@ -546,7 +562,17 @@ export default class CompareCriteria {
       message += "All values of";
     }
 
-    message += ` ${data.criteriaFilter.checkOn}`;
+    /*
+     * Prefer a metric-specific display name over the generic "Metric Value"
+     * label when evaluating metric monitors.
+     */
+    const label: string =
+      data.metricDisplayName &&
+      data.criteriaFilter.checkOn === CheckOn.MetricValue
+        ? data.metricDisplayName
+        : data.criteriaFilter.checkOn;
+
+    message += ` ${label}`;
 
     if (data.criteriaFilter.checkOn === CheckOn.DiskUsagePercent) {
       const diskPath: string =
@@ -562,6 +588,8 @@ export default class CompareCriteria {
       message += ` over the last ${data.criteriaFilter.evaluateOverTimeOptions.timeValueInMinutes} minutes`;
     }
 
+    const unitSuffix: string = data.unit ? ` ${data.unit}` : "";
+
     if (
       data.criteriaFilter.filterType !== FilterType.True &&
       data.criteriaFilter.filterType !== FilterType.False
@@ -570,29 +598,29 @@ export default class CompareCriteria {
         data.values,
       );
 
-      message += ` is ${formattedValues}`;
+      message += ` is ${formattedValues}${unitSuffix}`;
 
       message += " which is";
     }
 
     switch (data.criteriaFilter.filterType) {
       case FilterType.GreaterThan:
-        message += ` greater than ${CompareCriteria.formatSingleValue(data.threshold)}. `;
+        message += ` greater than ${CompareCriteria.formatSingleValue(data.threshold)}${unitSuffix}. `;
         break;
       case FilterType.GreaterThanOrEqualTo:
-        message += ` greater than or equal to ${CompareCriteria.formatSingleValue(data.threshold)}. `;
+        message += ` greater than or equal to ${CompareCriteria.formatSingleValue(data.threshold)}${unitSuffix}. `;
         break;
       case FilterType.LessThan:
-        message += ` less than ${CompareCriteria.formatSingleValue(data.threshold)}. `;
+        message += ` less than ${CompareCriteria.formatSingleValue(data.threshold)}${unitSuffix}. `;
         break;
       case FilterType.LessThanOrEqualTo:
-        message += ` less than or equal to ${CompareCriteria.formatSingleValue(data.threshold)}. `;
+        message += ` less than or equal to ${CompareCriteria.formatSingleValue(data.threshold)}${unitSuffix}. `;
         break;
       case FilterType.NotEqualTo:
-        message += ` not equal to ${CompareCriteria.formatSingleValue(data.threshold)}. `;
+        message += ` not equal to ${CompareCriteria.formatSingleValue(data.threshold)}${unitSuffix}. `;
         break;
       case FilterType.EqualTo:
-        message += ` equal to ${CompareCriteria.formatSingleValue(data.threshold)}. `;
+        message += ` equal to ${CompareCriteria.formatSingleValue(data.threshold)}${unitSuffix}. `;
         break;
       case FilterType.Contains:
         message += ` contains ${CompareCriteria.formatSingleValue(data.threshold)}. `;
@@ -621,11 +649,45 @@ export default class CompareCriteria {
     values: Array<number | boolean> | number | boolean | string,
   ): string {
     if (Array.isArray(values)) {
-      return values
+      /*
+       * For a small number of values, list them verbatim so the message
+       * reads naturally ("is 42, 55, 60"). For larger arrays, summarize
+       * — dumping 30+ numbers on one line makes the root cause unreadable
+       * and the detailed breakdown is shown in the Breaching Samples
+       * table below.
+       */
+      const MAX_INLINE: number = 5;
+
+      if (values.length <= MAX_INLINE) {
+        return values
+          .map((value: number | boolean) => {
+            return CompareCriteria.formatSingleValue(value);
+          })
+          .join(", ");
+      }
+
+      const numericValues: Array<number> = values.filter(
+        (value: number | boolean): value is number => {
+          return typeof value === "number" && Number.isFinite(value);
+        },
+      );
+
+      if (numericValues.length === values.length && numericValues.length > 0) {
+        const min: number = Math.min(...numericValues);
+        const max: number = Math.max(...numericValues);
+        return `${numericValues.length} samples between ${CompareCriteria.formatSingleValue(
+          min,
+        )} and ${CompareCriteria.formatSingleValue(max)}`;
+      }
+
+      // Fall back to a truncated list when not all values are numeric
+      const head: string = values
+        .slice(0, MAX_INLINE)
         .map((value: number | boolean) => {
           return CompareCriteria.formatSingleValue(value);
         })
         .join(", ");
+      return `${head}, … (${values.length} values total)`;
     }
 
     return CompareCriteria.formatSingleValue(values);