@oneuptime/common 11.7.0 → 11.7.2

package/Server/Services/WorkspaceNotificationRuleService.ts

@@ -31,6 +31,8 @@ import WorkspaceMessagePayload, {
   WorkspacePayloadMarkdown,
 } from "../../Types/Workspace/WorkspaceMessagePayload";
 import WorkspaceProjectAuthToken, {
+  MicrosoftTeamsChat,
+  MicrosoftTeamsMiscData,
   MiscData,
   SlackMiscData,
 } from "../../Models/DatabaseModels/WorkspaceProjectAuthToken";
@@ -445,6 +447,97 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
         }
       }
     }
+
+    // Post test message to Microsoft Teams chats.
+    if (
+      rule.workspaceType === WorkspaceType.MicrosoftTeams &&
+      notificationRule.shouldPostToExistingChat
+    ) {
+      const chatIds: Array<string> =
+        this.getExistingChatIdsFromNotificationRules({
+          notificationRules: [notificationRule],
+        });
+
+      if (chatIds.length === 0) {
+        throw new BadDataException(
+          "No Microsoft Teams chats are selected in this rule. Please edit the rule and select at least one chat.",
+        );
+      }
+
+      const connectedChats: Record<string, MicrosoftTeamsChat> =
+        await this.getConnectedMicrosoftTeamsChats({
+          projectId: data.projectId,
+        });
+
+      for (const chatId of chatIds) {
+        if (!connectedChats[chatId]) {
+          throw new BadDataException(
+            `The selected chat (id: ${chatId}) is no longer connected to OneUptime. Please add the OneUptime app to the chat in Microsoft Teams and update this rule.`,
+          );
+        }
+      }
+
+      try {
+        const responses: Array<WorkspaceSendMessageResponse> =
+          await WorkspaceUtil.postMessageToAllWorkspaceChannelsAsBot({
+            projectId: data.projectId,
+            messagePayloadsByWorkspace: messageBlocksByWorkspaceTypes.map(
+              (messageBlocksByWorkspaceType: MessageBlocksByWorkspaceType) => {
+                const payload: WorkspaceMessagePayload = {
+                  _type: "WorkspaceMessagePayload",
+                  workspaceType: messageBlocksByWorkspaceType.workspaceType,
+                  messageBlocks: messageBlocksByWorkspaceType.messageBlocks,
+                  channelNames: [],
+                  channelIds: [],
+                  chatIds: chatIds,
+                };
+
+                return payload;
+              },
+            ),
+          });
+
+        for (const res of responses) {
+          // Check for errors in the response
+          if (res.errors && res.errors.length > 0) {
+            const errorMessages: Array<string> = res.errors.map(
+              (error: { channel: WorkspaceChannel; error: string }) => {
+                return `Chat ${error.channel.name}: ${error.error}`;
+              },
+            );
+            throw new BadDataException(
+              `Failed to send test message to some chats: ${errorMessages.join(
+                "; ",
+              )}`,
+            );
+          }
+
+          for (const thread of res.threads) {
+            const log: WorkspaceNotificationLog =
+              new WorkspaceNotificationLog();
+            log.projectId = data.projectId;
+            log.workspaceType = res.workspaceType;
+            log.channelId = thread.channel.id;
+            log.channelName = thread.channel.name;
+            log.threadId = thread.threadId;
+            log.message = `This is a test message for rule **${rule.name?.trim()}**`;
+            log.status = WorkspaceNotificationStatus.Success;
+            log.statusMessage = "Test message posted to workspace chat";
+            log.userId = data.testByUserId;
+            log.actionType = WorkspaceNotificationActionType.SendMessage;
+
+            await WorkspaceNotificationLogService.create({
+              data: log,
+              props: { isRoot: true },
+            });
+          }
+        }
+      } catch (err) {
+        throw new BadDataException(
+          "Cannot post message to chat. " + (err as Error)?.message,
+        );
+      }
+    }
   }
 
   @CaptureSpan()
@@ -614,6 +707,29 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
         };
         workspaceNotificationPaylaods.push(workspaceMessagePayload);
       }
+
+      // Microsoft Teams chats (group / personal chats the OneUptime app was added to).
+      const existingChatIds: Array<string> =
+        await this.getExistingChatIdsBasedOnEventType({
+          projectId: data.projectId,
+          notificationRuleEventType: this.getNotificationRuleEventType(
+            data.notificationFor,
+          ),
+          workspaceType: messageBlocksByWorkspaceType.workspaceType,
+          notificationFor: data.notificationFor,
+        });
+
+      for (const chatId of existingChatIds) {
+        const workspaceMessagePayload: WorkspaceMessagePayload = {
+          _type: "WorkspaceMessagePayload",
+          workspaceType: messageBlocksByWorkspaceType.workspaceType,
+          messageBlocks: messageBlocksByWorkspaceType.messageBlocks,
+          channelNames: [],
+          channelIds: [],
+          chatIds: [chatId],
+        };
+        workspaceNotificationPaylaods.push(workspaceMessagePayload);
+      }
     }
 
     const responses: Array<WorkspaceSendMessageResponse> =
@@ -655,8 +771,8 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
         const log: WorkspaceNotificationLog = new WorkspaceNotificationLog();
         log.projectId = data.projectId;
         log.workspaceType = res.workspaceType;
-        log.channelId = thread.channel.id;
-        log.channelName = thread.channel.name;
+        log.channelId = (thread.channel.id || "").substring(0, 100);
+        log.channelName = (thread.channel.name || "").substring(0, 100);
         log.threadId = thread.threadId;
         log.message = messageSummary;
         log.status = WorkspaceNotificationStatus.Success;
@@ -683,6 +799,45 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
           props: { isRoot: true },
         });
       }
+
+      /*
+       * Also log per-destination failures — otherwise a chat or channel
+       * send that errors (e.g. the OneUptime app was removed from a chat a
+       * rule still references) is invisible in the notification logs.
+       */
+      for (const sendError of res.errors || []) {
+        const log: WorkspaceNotificationLog = new WorkspaceNotificationLog();
+        log.projectId = data.projectId;
+        log.workspaceType = res.workspaceType;
+        log.channelId = (sendError.channel.id || "").substring(0, 100);
+        log.channelName = (sendError.channel.name || "").substring(0, 100);
+        log.message = messageSummary;
+        log.status = WorkspaceNotificationStatus.Error;
+        log.actionType = WorkspaceNotificationActionType.SendMessage;
+        log.statusMessage = (sendError.error || "Failed to send message")
+          .toString()
+          .substring(0, 500);
+
+        if (data.notificationFor.incidentId) {
+          log.incidentId = data.notificationFor.incidentId;
+        }
+        if (data.notificationFor.alertId) {
+          log.alertId = data.notificationFor.alertId;
+        }
+        if (data.notificationFor.scheduledMaintenanceId) {
+          log.scheduledMaintenanceId =
+            data.notificationFor.scheduledMaintenanceId;
+        }
+
+        if (data.workspaceNotification.notifyUserId) {
+          log.userId = data.workspaceNotification.notifyUserId;
+        }
+
+        await WorkspaceNotificationLogService.create({
+          data: log,
+          props: { isRoot: true },
+        });
+      }
     }
   }
 
@@ -1951,6 +2106,81 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
     return channels;
   }
 
+  /*
+   * Collects the Microsoft Teams chat ids (group / personal chats) that
+   * matching rules want to post to. Chats are Teams-only destinations.
+   */
+  public getExistingChatIdsFromNotificationRules(data: {
+    notificationRules: Array<BaseNotificationRule>;
+  }): Array<string> {
+    const chatIds: Array<string> = [];
+
+    for (const notificationRule of data.notificationRules) {
+      if (!notificationRule.shouldPostToExistingChat) {
+        continue;
+      }
+
+      for (const chatId of notificationRule.existingChatIds || []) {
+        if (!chatId) {
+          continue;
+        }
+
+        if (!chatIds.includes(chatId)) {
+          chatIds.push(chatId);
+        }
+      }
+    }
+
+    return chatIds;
+  }
+
+  @CaptureSpan()
+  public async getExistingChatIdsBasedOnEventType(data: {
+    projectId: ObjectID;
+    workspaceType: WorkspaceType;
+    notificationRuleEventType: NotificationRuleEventType;
+    notificationFor: NotificationFor;
+  }): Promise<Array<string>> {
+    if (data.workspaceType !== WorkspaceType.MicrosoftTeams) {
+      return []; // chats are only supported for Microsoft Teams.
+    }
+
+    const notificationRules: Array<WorkspaceNotificationRule> =
+      await this.getMatchingNotificationRules({
+        projectId: data.projectId,
+        workspaceType: data.workspaceType,
+        notificationRuleEventType: data.notificationRuleEventType,
+        notificationFor: data.notificationFor,
+      });
+
+    return this.getExistingChatIdsFromNotificationRules({
+      notificationRules: notificationRules.map(
+        (rule: WorkspaceNotificationRule) => {
+          return rule.notificationRule as BaseNotificationRule;
+        },
+      ),
+    });
+  }
+
+  @CaptureSpan()
+  public async getConnectedMicrosoftTeamsChats(data: {
+    projectId: ObjectID;
+  }): Promise<Record<string, MicrosoftTeamsChat>> {
+    const projectAuth: WorkspaceProjectAuthToken | null =
+      await WorkspaceProjectAuthTokenService.getProjectAuth({
+        projectId: data.projectId,
+        workspaceType: WorkspaceType.MicrosoftTeams,
+      });
+
+    if (!projectAuth || !projectAuth.miscData) {
+      return {};
+    }
+
+    return (
+      (projectAuth.miscData as MicrosoftTeamsMiscData).availableChats || {}
+    );
+  }
+
   public getnotificationChannelssFromNotificationRules(data: {
     notificationEventType: NotificationRuleEventType;
     notificationRules: Array<WorkspaceNotificationRule>;

package/Server/Utils/Database/PostgresErrorTranslator.ts

@@ -0,0 +1,131 @@
+import BadDataException from "../../../Types/Exception/BadDataException";
+import Exception from "../../../Types/Exception/Exception";
+
+/*
+ * Postgres error codes we can turn into something the caller can act on.
+ * https://www.postgresql.org/docs/current/errcodes-appendix.html
+ */
+const FOREIGN_KEY_VIOLATION: string = "23503";
+
+/*
+ * TypeORM reports driver failures as QueryFailedError, which does not extend
+ * Exception. Those fall all the way through to the generic handler in
+ * StartServer and reach the client as a bare 500 `{"error": "Server Error"}`
+ * with nothing to act on — the user just sees "Server Error" in the UI.
+ *
+ * Translate the failures a user can actually do something about into a
+ * BadDataException so the API answers with a 400 and a readable message.
+ * Anything we do not recognise is returned untouched, so behaviour for the
+ * rest of the error surface is unchanged.
+ */
+
+interface PostgresDriverError {
+  code?: string | undefined;
+  table?: string | undefined;
+  detail?: string | undefined;
+}
+
+export default class PostgresErrorTranslator {
+  public static translate(error: unknown): unknown {
+    const driverError: PostgresDriverError | null =
+      this.getPostgresDriverError(error);
+
+    if (!driverError || driverError.code !== FOREIGN_KEY_VIOLATION) {
+      return error;
+    }
+
+    const detail: string = driverError.detail || "";
+
+    /*
+     * DELETE blocked by a child row:
+     *   Key (_id)=(...) is still referenced from table "MonitorStatusTimeline".
+     */
+    if (detail.includes("is still referenced from table")) {
+      const referencingTable: string =
+        this.getTableNameFromDetail(detail) || driverError.table || "";
+
+      return new BadDataException(
+        referencingTable
+          ? `This item cannot be deleted because ${this.humanizeTableName(
+              referencingTable,
+            )} records still reference it. Please delete those records first, and then try again.`
+          : "This item cannot be deleted because other records still reference it. Please delete those records first, and then try again.",
+      );
+    }
+
+    /*
+     * INSERT/UPDATE pointing at a row that does not exist:
+     *   Key (monitorStatusId)=(...) is not present in table "MonitorStatus".
+     */
+    if (detail.includes("is not present in table")) {
+      const referencedTable: string = this.getTableNameFromDetail(detail) || "";
+
+      return new BadDataException(
+        referencedTable
+          ? `This request references ${this.humanizeTableName(
+              referencedTable,
+            )} that does not exist. Please check the request and try again.`
+          : "This request references an item that does not exist. Please check the request and try again.",
+      );
+    }
+
+    return error;
+  }
+
+  /*
+   * `throw`-friendly wrapper. Kept synchronous so callers can keep using
+   * `throw translator(...)` on the synchronous throw path.
+   */
+  public static translateException(error: Exception): Exception {
+    return this.translate(error) as Exception;
+  }
+
+  private static getPostgresDriverError(
+    error: unknown,
+  ): PostgresDriverError | null {
+    if (!error || typeof error !== "object") {
+      return null;
+    }
+
+    /*
+     * QueryFailedError hoists the pg fields onto itself and also keeps the
+     * original under `driverError`. Prefer whichever one carries the code.
+     */
+    const candidate: PostgresDriverError = error as PostgresDriverError;
+
+    if (typeof candidate.code === "string") {
+      return candidate;
+    }
+
+    const driverError: unknown = (error as { driverError?: unknown })
+      .driverError;
+
+    if (
+      driverError &&
+      typeof driverError === "object" &&
+      typeof (driverError as PostgresDriverError).code === "string"
+    ) {
+      return driverError as PostgresDriverError;
+    }
+
+    return null;
+  }
+
+  private static getTableNameFromDetail(detail: string): string | null {
+    const match: RegExpMatchArray | null = detail.match(/table "([^"]+)"/);
+
+    return match && match[1] ? match[1] : null;
+  }
+
+  /*
+   * "MonitorStatusTimeline" -> "Monitor Status Timeline". Table names are the
+   * PascalCase model names, so this reads well enough to put in front of a
+   * user without maintaining a lookup table of display names.
+   */
+  private static humanizeTableName(tableName: string): string {
+    return tableName
+      .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+      .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
+      .trim();
+  }
+}

package/Server/Utils/Monitor/MonitorResource.ts

@@ -27,7 +27,9 @@ import ObjectID from "../../../Types/ObjectID";
 import ProbeApiIngestResponse from "../../../Types/Probe/ProbeApiIngestResponse";
 import ProbeMonitorResponse from "../../../Types/Probe/ProbeMonitorResponse";
 import Monitor from "../../../Models/DatabaseModels/Monitor";
-import MonitorProbe from "../../../Models/DatabaseModels/MonitorProbe";
+import MonitorProbe, {
+  MonitorStepProbeResponse,
+} from "../../../Models/DatabaseModels/MonitorProbe";
 import MonitorStatus from "../../../Models/DatabaseModels/MonitorStatus";
 import MonitorStatusTimeline from "../../../Models/DatabaseModels/MonitorStatusTimeline";
 import OneUptimeDate from "../../../Types/Date";
@@ -241,6 +243,16 @@ export default class MonitorResourceUtil {
       let probeName: string | undefined = undefined;
       const monitorName: string | undefined = monitor.name || undefined;
 
+      /*
+       * All MonitorProbe rows for this monitor, fetched once per result and
+       * reused by checkProbeAgreement below. The rows carry the heavy
+       * lastMonitoringLog jsonb, so re-fetching them per result was the
+       * second-largest read on the hottest Postgres path. Safe to reuse: the
+       * per-monitor semaphore above serializes every writer of these rows
+       * for the duration of this function.
+       */
+      let monitorProbesForMonitor: Array<MonitorProbe> | null = null;
+
       /*
        * SNMP trap responses are event-driven, not check results. They are
        * evaluated ONLY against trap criteria; they must not overwrite the
@@ -266,21 +278,39 @@ export default class MonitorResourceUtil {
       ) {
         dataToProcess = dataToProcess as ProbeMonitorResponse;
         if ((dataToProcess as ProbeMonitorResponse).probeId) {
-          const monitorProbe: MonitorProbe | null =
-            await MonitorProbeService.findOneBy({
-              query: {
-                monitorId: monitor.id!,
-                probeId: (dataToProcess as ProbeMonitorResponse).probeId!,
-              },
-              select: {
-                lastMonitoringLog: true,
-                probe: {
-                  name: true,
-                },
-              },
-              props: {
-                isRoot: true,
+          /*
+           * One query for every probe assigned to this monitor (instead of
+           * one for the current probe here plus another for all of them in
+           * checkProbeAgreement). The select is the union both consumers
+           * need.
+           */
+          monitorProbesForMonitor = await MonitorProbeService.findBy({
+            query: {
+              monitorId: monitor.id!,
+            },
+            select: {
+              _id: true,
+              probeId: true,
+              isEnabled: true,
+              lastMonitoringLog: true,
+              probe: {
+                name: true,
+                connectionStatus: true,
               },
+            },
+            limit: LIMIT_PER_PROJECT,
+            skip: 0,
+            props: {
+              isRoot: true,
+            },
+          });
+
+          const monitorProbe: MonitorProbe | undefined =
+            monitorProbesForMonitor.find((mp: MonitorProbe) => {
+              return (
+                mp.probeId?.toString() ===
+                (dataToProcess as ProbeMonitorResponse).probeId!.toString()
+              );
             });
 
           if (!monitorProbe) {
@@ -297,26 +327,39 @@ export default class MonitorResourceUtil {
            */
 
           if (!isSnmpTrapEvent) {
-            await MonitorProbeService.updateOneBy({
-              query: {
-                monitorId: monitor.id!,
-                probeId: (dataToProcess as ProbeMonitorResponse).probeId!,
+            /*
+             * Runs once per probe check result — the hottest recurring write
+             * in the product. The full updateOneBy pipeline would re-SELECT
+             * this row (including the large lastMonitoringLog jsonb we just
+             * fetched above) and then save() it (another SELECT + UPDATE in a
+             * transaction). MonitorProbe has no workflow/audit/realtime
+             * decorators, so those hooks were inert anyway — a single
+             * UPDATE by the id we already hold is equivalent and 3x cheaper.
+             * See the Monitor heartbeat writes below for the same pattern.
+             */
+            const updatedLastMonitoringLog: MonitorStepProbeResponse = {
+              ...(monitorProbe.lastMonitoringLog || {}),
+              [(
+                dataToProcess as ProbeMonitorResponse
+              ).monitorStepId.toString()]: {
+                ...JSON.parse(JSON.stringify(dataToProcess)),
+                monitoredAt: OneUptimeDate.getCurrentDate(),
               },
+            };
+
+            await MonitorProbeService.updateColumnsByIdWithoutHooks({
+              id: monitorProbe.id!,
               data: {
-                lastMonitoringLog: {
-                  ...(monitorProbe.lastMonitoringLog || {}),
-                  [(
-                    dataToProcess as ProbeMonitorResponse
-                  ).monitorStepId.toString()]: {
-                    ...JSON.parse(JSON.stringify(dataToProcess)),
-                    monitoredAt: OneUptimeDate.getCurrentDate(),
-                  },
-                } as any,
-              },
-              props: {
-                isRoot: true,
+                lastMonitoringLog: updatedLastMonitoringLog as any,
               },
             });
+
+            /*
+             * Mirror the write onto the in-memory row so checkProbeAgreement
+             * (which reuses monitorProbesForMonitor instead of re-querying)
+             * sees exactly what a fresh read would return.
+             */
+            monitorProbe.lastMonitoringLog = updatedLastMonitoringLog;
           }
         }
       }
@@ -639,6 +682,7 @@ export default class MonitorResourceUtil {
             monitorStep: monitorStep,
             currentCriteriaMetId: response.criteriaMetId || null,
             currentRootCause: response.rootCause || null,
+            monitorProbes: monitorProbesForMonitor || undefined,
           });
 
         // Add probe agreement event to evaluation summary
@@ -1084,6 +1128,15 @@ export default class MonitorResourceUtil {
     monitorStep: MonitorStep;
     currentCriteriaMetId: string | null;
     currentRootCause: string | null;
+    /*
+     * Pre-fetched MonitorProbe rows for this monitor (probeId, isEnabled,
+     * lastMonitoringLog, probe.name/connectionStatus). The probe-result hot
+     * path passes these to avoid re-reading every row's lastMonitoringLog
+     * jsonb per result; safe because the caller holds the per-monitor lock,
+     * so the rows cannot change underneath us. When absent, fall back to
+     * querying.
+     */
+    monitorProbes?: Array<MonitorProbe> | undefined;
   }): Promise<ProbeAgreementResult> {
     const { monitor, monitorStep, currentCriteriaMetId, currentRootCause } =
       input;
@@ -1092,8 +1145,9 @@ export default class MonitorResourceUtil {
      * If minimumProbeAgreement is not set, all probes must agree
      * Get all MonitorProbes for this monitor with their probe connection status
      */
-    const monitorProbes: Array<MonitorProbe> = await MonitorProbeService.findBy(
-      {
+    const monitorProbes: Array<MonitorProbe> =
+      input.monitorProbes ||
+      (await MonitorProbeService.findBy({
         query: {
           monitorId: monitor.id!,
         },
@@ -1111,8 +1165,7 @@ export default class MonitorResourceUtil {
         props: {
           isRoot: true,
         },
-      },
-    );
+      }));
 
     // Filter to only active probes (enabled AND connected)
     const activeProbes: Array<MonitorProbe> = monitorProbes.filter(

package/Server/Utils/Monitor/MonitorStatusTimeline.ts

@@ -27,6 +27,26 @@ export default class MonitorStatusTimelineUtil {
   }): Promise<MonitorStatusTimeline | null> {
     // criteria filters are met, now process the actions.
 
+    /*
+     * Steady-state fast-path: the criteria's target status is already the
+     * monitor's current status (the standard "online criteria matched on a
+     * healthy check" case, i.e. almost every probe result). The sorted
+     * timeline SELECT below could only confirm what currentMonitorStatusId
+     * already tells us — Monitor.currentMonitorStatusId is kept in lockstep
+     * with the latest timeline row by MonitorStatusTimelineService — and the
+     * function would return null via the same-as-last-status check anyway.
+     * Skip the query entirely. MonitorStatusTimelineService.onBeforeCreate
+     * still dedupes as the concurrency backstop.
+     */
+    if (
+      input.criteriaInstance.data?.changeMonitorStatus &&
+      input.criteriaInstance.data?.monitorStatusId &&
+      input.criteriaInstance.data.monitorStatusId.toString() ===
+        input.monitor.currentMonitorStatusId?.toString()
+    ) {
+      return null;
+    }
+
     const lastMonitorStatusTimeline: MonitorStatusTimeline | null =
       await MonitorStatusTimelineService.findOneBy({
         query: {
@@ -56,7 +76,7 @@ export default class MonitorStatusTimelineUtil {
       input.criteriaInstance.data?.changeMonitorStatus &&
       input.criteriaInstance.data?.monitorStatusId &&
       input.criteriaInstance.data?.monitorStatusId.toString() !==
-        lastMonitorStatusTimeline?.id?.toString()
+        lastMonitorStatusTimeline?.monitorStatusId?.toString()
     ) {
       // if monitor status is changed, then create a new status timeline.
       shouldUpdateStatus = true;