@oneuptime/common 9.5.8 → 9.5.10

package/Server/Services/IncidentEpisodeService.ts

@@ -33,6 +33,8 @@ import User from "../../Models/DatabaseModels/User";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import NotificationRuleWorkspaceChannel from "../../Types/Workspace/NotificationRules/NotificationRuleWorkspaceChannel";
 import WorkspaceType from "../../Types/Workspace/WorkspaceType";
+import IncidentEpisodeWorkspaceMessages from "../Utils/Workspace/WorkspaceMessages/IncidentEpisode";
+import { MessageBlocksByWorkspaceType } from "./WorkspaceNotificationRuleService";
 import IncidentService from "./IncidentService";
 import OnCallDutyPolicyService from "./OnCallDutyPolicyService";
 import OnCallDutyPolicy from "../../Models/DatabaseModels/OnCallDutyPolicy";
@@ -147,6 +149,17 @@ export class Service extends DatabaseService<Model> {
 
     // Create initial state timeline entry
     Promise.resolve()
+      .then(async () => {
+        try {
+          if (createdItem.projectId && createdItem.id) {
+            await this.handleEpisodeWorkspaceOperationsAsync(createdItem);
+          }
+        } catch (error) {
+          logger.error(
+            `Workspace operations failed in IncidentEpisodeService.onCreateSuccess: ${error}`,
+          );
+        }
+      })
       .then(async () => {
         try {
           await this.changeEpisodeState({
@@ -193,6 +206,51 @@ export class Service extends DatabaseService<Model> {
     return createdItem;
   }
 
+  @CaptureSpan()
+  private async handleEpisodeWorkspaceOperationsAsync(
+    createdItem: Model,
+  ): Promise<void> {
+    try {
+      if (!createdItem.projectId || !createdItem.id) {
+        throw new BadDataException(
+          "projectId and id are required for workspace operations",
+        );
+      }
+
+      const workspaceResult: {
+        channelsCreated: Array<NotificationRuleWorkspaceChannel>;
+      } | null =
+        await IncidentEpisodeWorkspaceMessages.createChannelsAndInviteUsersToChannels(
+          {
+            projectId: createdItem.projectId,
+            incidentEpisodeId: createdItem.id,
+            episodeNumber: createdItem.episodeNumber || 0,
+            ...(createdItem.episodeNumberWithPrefix
+              ? {
+                  episodeNumberWithPrefix: createdItem.episodeNumberWithPrefix,
+                }
+              : {}),
+          },
+        );
+
+      if (workspaceResult && workspaceResult.channelsCreated?.length > 0) {
+        await this.updateOneById({
+          id: createdItem.id,
+          data: {
+            postUpdatesToWorkspaceChannels:
+              workspaceResult.channelsCreated || [],
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+      }
+    } catch (error) {
+      logger.error(`Error in handleEpisodeWorkspaceOperationsAsync: ${error}`);
+      throw error;
+    }
+  }
+
   @CaptureSpan()
   private async createEpisodeCreatedFeed(episode: Model): Promise<void> {
     if (!episode.id || !episode.projectId) {
@@ -213,6 +271,14 @@ export class Service extends DatabaseService<Model> {
       feedInfoInMarkdown += `This episode was manually created.\n\n`;
     }
 
+    const episodeCreateMessageBlocks: Array<MessageBlocksByWorkspaceType> =
+      await IncidentEpisodeWorkspaceMessages.getIncidentEpisodeCreateMessageBlocks(
+        {
+          incidentEpisodeId: episode.id,
+          projectId: episode.projectId,
+        },
+      );
+
     await IncidentEpisodeFeedService.createIncidentEpisodeFeedItem({
       incidentEpisodeId: episode.id,
       projectId: episode.projectId,
@@ -220,6 +286,10 @@ export class Service extends DatabaseService<Model> {
       displayColor: Red500,
       feedInfoInMarkdown: feedInfoInMarkdown,
       userId: episode.createdByUserId || undefined,
+      workspaceNotification: {
+        appendMessageBlocks: episodeCreateMessageBlocks,
+        sendWorkspaceNotification: true,
+      },
     });
   }
 
@@ -952,21 +1022,30 @@ export class Service extends DatabaseService<Model> {
   }
 
   @CaptureSpan()
-  public getWorkspaceChannelForEpisode(
-    episode: Model,
-    workspaceType: WorkspaceType,
-  ): Array<NotificationRuleWorkspaceChannel> {
-    if (
-      !episode.postUpdatesToWorkspaceChannels ||
-      !Array.isArray(episode.postUpdatesToWorkspaceChannels) ||
-      episode.postUpdatesToWorkspaceChannels.length === 0
-    ) {
-      return [];
+  public async getWorkspaceChannelForEpisode(data: {
+    episodeId: ObjectID;
+    workspaceType?: WorkspaceType | null;
+  }): Promise<Array<NotificationRuleWorkspaceChannel>> {
+    const episode: Model | null = await this.findOneById({
+      id: data.episodeId,
+      select: {
+        postUpdatesToWorkspaceChannels: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!episode) {
+      throw new BadDataException("Incident Episode not found.");
     }
 
-    return episode.postUpdatesToWorkspaceChannels.filter(
+    return (episode.postUpdatesToWorkspaceChannels || []).filter(
       (channel: NotificationRuleWorkspaceChannel) => {
-        return channel.workspaceType === workspaceType;
+        if (!data.workspaceType) {
+          return true;
+        }
+        return channel.workspaceType === data.workspaceType;
       },
     );
   }

package/Server/Services/IncidentEpisodeStateTimelineService.ts

@@ -383,6 +383,11 @@ export class Service extends DatabaseService<IncidentEpisodeStateTimeline> {
         ? `**Cause:** \n${createdItem.rootCause}`
         : undefined,
       userId: createdItem.createdByUserId || onCreate.createBy.props.userId,
+      workspaceNotification: {
+        sendWorkspaceNotification: true,
+        notifyUserId:
+          createdItem.createdByUserId || onCreate.createBy.props.userId,
+      },
     });
 
     return createdItem;

package/Server/Services/IncidentService.ts

@@ -843,6 +843,11 @@ export class Service extends DatabaseService<Model> {
           projectId: createdItem.projectId,
           incidentId: createdItem.id,
           incidentNumber: createdItem.incidentNumber!,
+          ...(createdItem.incidentNumberWithPrefix
+            ? {
+                incidentNumberWithPrefix: createdItem.incidentNumberWithPrefix,
+              }
+            : {}),
         });
 
       if (workspaceResult && workspaceResult.channelsCreated?.length > 0) {

package/Server/Services/MonitorService.ts

@@ -127,6 +127,14 @@ export class Service extends DatabaseService<Model> {
             monitorDestination = `${monitorDestination}:${port}`;
           }
         }
+
+        // For DNS monitors, use the queryName from dnsMonitor config
+        if (monitorType === MonitorType.DNS && firstStep?.data?.dnsMonitor) {
+          monitorDestination = firstStep.data.dnsMonitor.queryName || "";
+          if (firstStep.data.dnsMonitor.hostname) {
+            monitorDestination = `${monitorDestination} @${firstStep.data.dnsMonitor.hostname}`;
+          }
+        }
       }
     }
 

package/Server/Services/WorkspaceNotificationRuleService.ts

@@ -52,6 +52,7 @@ import WorkspaceNotificationActionType from "../../Types/Workspace/WorkspaceNoti
 import ExceptionMessages from "../../Types/Exception/ExceptionMessages";
 import IncidentEpisode from "../../Models/DatabaseModels/IncidentEpisode";
 import IncidentEpisodeService from "./IncidentEpisodeService";
+import AlertEpisodeService from "./AlertEpisodeService";
 
 export interface MessageBlocksByWorkspaceType {
   workspaceType: WorkspaceType;
@@ -735,6 +736,25 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
         );
     }
 
+    // incident episodes
+    if (data.notificationFor.incidentEpisodeId) {
+      monitorChannels =
+        await IncidentEpisodeService.getWorkspaceChannelForEpisode({
+          episodeId: data.notificationFor.incidentEpisodeId,
+          workspaceType: data.workspaceType,
+        });
+    }
+
+    // alert episodes
+    if (data.notificationFor.alertEpisodeId) {
+      monitorChannels = await AlertEpisodeService.getWorkspaceChannelForEpisode(
+        {
+          episodeId: data.notificationFor.alertEpisodeId,
+          workspaceType: data.workspaceType,
+        },
+      );
+    }
+
     logger.debug("Workspace channels found:");
     logger.debug(monitorChannels);
 
@@ -1785,9 +1805,18 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
         logger.debug("New channel template name:");
         logger.debug(notificationChannels);
 
+        /*
+         * Sanitize the suffix for workspace channel names.
+         * When no custom prefix is set, the default "#" prefix (e.g. "#42") produces
+         * invalid Slack channel names (e.g. "oneuptime-alert-#42"). Strip characters
+         * that are not valid in Slack/Teams channel names.
+         */
+        const sanitizedSuffix: string = data.channelNameSiffix
+          .toLowerCase()
+          .replace(/[^a-z0-9\-_]/g, "");
+
         // add suffix and then check if it is already added or not.
-        const channelName: string =
-          notificationChannels + data.channelNameSiffix;
+        const channelName: string = notificationChannels + sanitizedSuffix;
 
         logger.debug("Final channel name with suffix:");
         logger.debug(channelName);

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

@@ -0,0 +1,183 @@
+import DataToProcess from "../DataToProcess";
+import CompareCriteria from "./CompareCriteria";
+import {
+  CheckOn,
+  CriteriaFilter,
+  FilterType,
+} from "../../../../Types/Monitor/CriteriaFilter";
+import DnsMonitorResponse from "../../../../Types/Monitor/DnsMonitor/DnsMonitorResponse";
+import ProbeMonitorResponse from "../../../../Types/Probe/ProbeMonitorResponse";
+import EvaluateOverTime from "./EvaluateOverTime";
+import CaptureSpan from "../../Telemetry/CaptureSpan";
+import logger from "../../Logger";
+
+export default class DnsMonitorCriteria {
+  @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 dnsResponse: DnsMonitorResponse | undefined =
+      dataToProcess.dnsResponse;
+
+    let overTimeValue: Array<number | boolean> | number | boolean | undefined =
+      undefined;
+
+    if (
+      input.criteriaFilter.evaluateOverTime &&
+      input.criteriaFilter.evaluateOverTimeOptions
+    ) {
+      try {
+        overTimeValue = await EvaluateOverTime.getValueOverTime({
+          projectId: (input.dataToProcess as ProbeMonitorResponse).projectId,
+          monitorId: input.dataToProcess.monitorId!,
+          evaluateOverTimeOptions: input.criteriaFilter.evaluateOverTimeOptions,
+          metricType: input.criteriaFilter.checkOn,
+        });
+
+        if (Array.isArray(overTimeValue) && overTimeValue.length === 0) {
+          overTimeValue = undefined;
+        }
+      } catch (err) {
+        logger.error(
+          `Error in getting over time value for ${input.criteriaFilter.checkOn}`,
+        );
+        logger.error(err);
+        overTimeValue = undefined;
+      }
+    }
+
+    // Check if DNS is online
+    if (input.criteriaFilter.checkOn === CheckOn.DnsIsOnline) {
+      const currentIsOnline: boolean | Array<boolean> =
+        (overTimeValue as Array<boolean>) ||
+        (input.dataToProcess as ProbeMonitorResponse).isOnline;
+
+      return CompareCriteria.compareCriteriaBoolean({
+        value: currentIsOnline,
+        criteriaFilter: input.criteriaFilter,
+      });
+    }
+
+    // Check DNS response time
+    if (input.criteriaFilter.checkOn === CheckOn.DnsResponseTime) {
+      threshold = CompareCriteria.convertToNumber(threshold);
+
+      if (threshold === null || threshold === undefined) {
+        return null;
+      }
+
+      const currentResponseTime: number | Array<number> =
+        (overTimeValue as Array<number>) ||
+        dnsResponse?.responseTimeInMs ||
+        (input.dataToProcess as ProbeMonitorResponse).responseTimeInMs;
+
+      if (currentResponseTime === null || currentResponseTime === undefined) {
+        return null;
+      }
+
+      return CompareCriteria.compareCriteriaNumbers({
+        value: currentResponseTime,
+        threshold: threshold as number,
+        criteriaFilter: input.criteriaFilter,
+      });
+    }
+
+    // Check if DNS record exists
+    if (input.criteriaFilter.checkOn === CheckOn.DnsRecordExists) {
+      const exists: boolean = Boolean(
+        dnsResponse?.records && dnsResponse.records.length > 0,
+      );
+
+      const isTrue: boolean =
+        input.criteriaFilter.filterType === FilterType.True;
+      const isFalse: boolean =
+        input.criteriaFilter.filterType === FilterType.False;
+
+      if (exists && isTrue) {
+        return `DNS records exist for the query.`;
+      }
+
+      if (!exists && isFalse) {
+        return `No DNS records found for the query.`;
+      }
+
+      return null;
+    }
+
+    // Check DNSSEC validity
+    if (input.criteriaFilter.checkOn === CheckOn.DnssecIsValid) {
+      const isTrue: boolean =
+        input.criteriaFilter.filterType === FilterType.True;
+      const isFalse: boolean =
+        input.criteriaFilter.filterType === FilterType.False;
+
+      if (dnsResponse?.isDnssecValid === undefined) {
+        return null;
+      }
+
+      if (dnsResponse.isDnssecValid && isTrue) {
+        return `DNSSEC is valid.`;
+      }
+
+      if (!dnsResponse.isDnssecValid && isFalse) {
+        return `DNSSEC is not valid.`;
+      }
+
+      return null;
+    }
+
+    // Check DNS record value
+    if (input.criteriaFilter.checkOn === CheckOn.DnsRecordValue) {
+      if (!dnsResponse?.records || dnsResponse.records.length === 0) {
+        return null;
+      }
+
+      // Check if any record value matches the criteria
+      for (const record of dnsResponse.records) {
+        const recordValue: string = record.value;
+
+        // Try numeric comparison first
+        if (
+          typeof threshold === "number" ||
+          (typeof threshold === "string" && !isNaN(Number(threshold)))
+        ) {
+          const numericThreshold: number | null =
+            CompareCriteria.convertToNumber(threshold);
+
+          if (numericThreshold !== null && !isNaN(Number(recordValue))) {
+            const result: string | null =
+              CompareCriteria.compareCriteriaNumbers({
+                value: Number(recordValue),
+                threshold: numericThreshold,
+                criteriaFilter: input.criteriaFilter,
+              });
+
+            if (result) {
+              return `DNS record (${record.type}): ${result}`;
+            }
+          }
+        }
+
+        // String comparison
+        const result: string | null = CompareCriteria.compareCriteriaStrings({
+          value: recordValue,
+          threshold: String(threshold),
+          criteriaFilter: input.criteriaFilter,
+        });
+
+        if (result) {
+          return `DNS record (${record.type}): ${result}`;
+        }
+      }
+    }
+
+    return null;
+  }
+}

package/Server/Utils/Monitor/MonitorCriteriaEvaluator.ts

@@ -12,6 +12,7 @@ import MetricMonitorCriteria from "./Criteria/MetricMonitorCriteria";
 import TraceMonitorCriteria from "./Criteria/TraceMonitorCriteria";
 import ExceptionMonitorCriteria from "./Criteria/ExceptionMonitorCriteria";
 import SnmpMonitorCriteria from "./Criteria/SnmpMonitorCriteria";
+import DnsMonitorCriteria from "./Criteria/DnsMonitorCriteria";
 import MonitorCriteriaMessageBuilder from "./MonitorCriteriaMessageBuilder";
 import MonitorCriteriaDataExtractor from "./MonitorCriteriaDataExtractor";
 import MonitorCriteriaMessageFormatter from "./MonitorCriteriaMessageFormatter";
@@ -493,6 +494,18 @@ ${contextBlock}
       }
     }
 
+    if (input.monitor.monitorType === MonitorType.DNS) {
+      const dnsMonitorResult: string | null =
+        await DnsMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess: input.dataToProcess,
+          criteriaFilter: input.criteriaFilter,
+        });
+
+      if (dnsMonitorResult) {
+        return dnsMonitorResult;
+      }
+    }
+
     return null;
   }
 

package/Server/Utils/Monitor/MonitorTemplateUtil.ts

@@ -14,6 +14,9 @@ import SyntheticMonitorResponse from "../../../Types/Monitor/SyntheticMonitors/S
 import SnmpMonitorResponse, {
   SnmpOidResponse,
 } from "../../../Types/Monitor/SnmpMonitor/SnmpMonitorResponse";
+import DnsMonitorResponse, {
+  DnsRecordResponse,
+} from "../../../Types/Monitor/DnsMonitor/DnsMonitorResponse";
 import Typeof from "../../../Types/Typeof";
 import VMUtil from "../VM/VMAPI";
 import DataToProcess from "./DataToProcess";
@@ -240,6 +243,40 @@ export default class MonitorTemplateUtil {
           }
         }
       }
+
+      if (data.monitorType === MonitorType.DNS) {
+        const dnsResponse: DnsMonitorResponse | undefined = (
+          data.dataToProcess as ProbeMonitorResponse
+        ).dnsResponse;
+
+        storageMap = {
+          isOnline: (data.dataToProcess as ProbeMonitorResponse).isOnline,
+          responseTimeInMs: dnsResponse?.responseTimeInMs,
+          failureCause: dnsResponse?.failureCause,
+          isTimeout: dnsResponse?.isTimeout,
+          isDnssecValid: dnsResponse?.isDnssecValid,
+        } as JSONObject;
+
+        // Add DNS records
+        if (dnsResponse?.records) {
+          storageMap["records"] = dnsResponse.records.map(
+            (record: DnsRecordResponse) => {
+              return {
+                type: record.type,
+                value: record.value,
+                ttl: record.ttl,
+              };
+            },
+          );
+
+          // Add record values as a flat array for easier templating
+          storageMap["recordValues"] = dnsResponse.records.map(
+            (record: DnsRecordResponse) => {
+              return record.value;
+            },
+          );
+        }
+      }
     } catch (err) {
       logger.error(err);
     }

package/Server/Utils/Workspace/MicrosoftTeams/Actions/Alert.ts

@@ -361,7 +361,7 @@ export default class MicrosoftTeamsAlertActions {
         await this.buildExecuteAlertOnCallPolicyCard(actionValue, projectId);
       if (!card) {
         await turnContext.sendActivity(
-          "No on-call policies found in the project",
+          "No on-call policies have been configured for this project yet. Please add an on-call policy in the OneUptime Dashboard under On-Call Duty > Policies to use this feature.",
         );
         return;
       }

package/Server/Utils/Workspace/MicrosoftTeams/Actions/AlertEpisode.ts

@@ -391,7 +391,7 @@ export default class MicrosoftTeamsAlertEpisodeActions {
         );
       if (!card) {
         await turnContext.sendActivity(
-          "No on-call policies found in the project",
+          "No on-call policies have been configured for this project yet. Please add an on-call policy in the OneUptime Dashboard under On-Call Duty > Policies to use this feature.",
         );
         return;
       }
@@ -495,11 +495,12 @@ export default class MicrosoftTeamsAlertEpisodeActions {
         // Update the state
         const episodeId: ObjectID = new ObjectID(actionValue);
 
-        await AlertEpisodeService.updateOneById({
-          id: episodeId,
-          data: {
-            currentAlertStateId: new ObjectID(alertStateId.toString()),
-          },
+        await AlertEpisodeService.changeEpisodeState({
+          projectId: projectId,
+          episodeId: episodeId,
+          alertStateId: new ObjectID(alertStateId.toString()),
+          notifyOwners: true,
+          rootCause: "State changed via Microsoft Teams.",
           props: {
             isRoot: true,
           },

package/Server/Utils/Workspace/MicrosoftTeams/Actions/Incident.ts

@@ -424,7 +424,7 @@ export default class MicrosoftTeamsIncidentActions {
       );
       if (!card) {
         await turnContext.sendActivity(
-          "No on-call policies found in the project",
+          "No on-call policies have been configured for this project yet. Please add an on-call policy in the OneUptime Dashboard under On-Call Duty > Policies to use this feature.",
         );
         return;
       }

package/Server/Utils/Workspace/MicrosoftTeams/Actions/IncidentEpisode.ts

@@ -403,7 +403,7 @@ export default class MicrosoftTeamsIncidentEpisodeActions {
         );
       if (!card) {
         await turnContext.sendActivity(
-          "No on-call policies found in the project",
+          "No on-call policies have been configured for this project yet. Please add an on-call policy in the OneUptime Dashboard under On-Call Duty > Policies to use this feature.",
         );
         return;
       }
@@ -505,11 +505,12 @@ export default class MicrosoftTeamsIncidentEpisodeActions {
         // Update the state
         const episodeId: ObjectID = new ObjectID(actionValue);
 
-        await IncidentEpisodeService.updateOneById({
-          id: episodeId,
-          data: {
-            currentIncidentStateId: new ObjectID(incidentStateId.toString()),
-          },
+        await IncidentEpisodeService.changeEpisodeState({
+          projectId: projectId,
+          episodeId: episodeId,
+          incidentStateId: new ObjectID(incidentStateId.toString()),
+          notifyOwners: true,
+          rootCause: "State changed via Microsoft Teams.",
           props: {
             isRoot: true,
           },

package/Server/Utils/Workspace/MicrosoftTeams/MicrosoftTeams.ts

@@ -780,13 +780,14 @@ export default class MicrosoftTeamsUtil extends WorkspaceBase {
 
     const workspaceChannels: Array<WorkspaceChannel> = [];
 
-    for (let channelName of data.channelNames) {
-      // Normalize channel name - Teams has different naming requirements
-      if (channelName && channelName.startsWith("#")) {
-        channelName = channelName.substring(1);
-      }
-      // Teams channels cannot have spaces in the name for some operations
-      const normalizedChannelName: string = channelName.replace(/\s+/g, "-");
+    for (const channelName of data.channelNames) {
+      /*
+       * Normalize channel name: replace spaces with hyphens, then strip
+       * characters not valid in Teams channel names (e.g. #, %, &, *, etc.).
+       */
+      const normalizedChannelName: string = channelName
+        .replace(/\s+/g, "-")
+        .replace(/[^a-zA-Z0-9\-_]/g, "");
 
       // Check if channel exists
       const existingChannel: WorkspaceChannel | null =
@@ -839,6 +840,9 @@ export default class MicrosoftTeamsUtil extends WorkspaceBase {
   }): Promise<WorkspaceChannel> {
     const teamId: string = data.teamId;
 
+    // Sanitize channel name: strip characters not valid in Teams channel names.
+    data.channelName = data.channelName.replace(/[^a-zA-Z0-9\-_\s]/g, "");
+
     // Get valid access token
     const accessToken: string = await this.getValidAccessToken({
       authToken: data.authToken,

package/Server/Utils/Workspace/Slack/Actions/Alert.ts

@@ -322,6 +322,23 @@ export default class SlackAlertActions {
         return option.label !== "" || option.value !== "";
       });
 
+    if (dropdownOption.length === 0) {
+      if (data.slackRequest.slackChannelId) {
+        await SlackUtil.sendEphemeralMessageToChannel({
+          messageBlocks: [
+            {
+              _type: "WorkspacePayloadMarkdown",
+              text: "No on-call policies have been configured for this project yet. Please add an on-call policy in the OneUptime Dashboard under On-Call Duty > Policies to use this feature.",
+            } as WorkspacePayloadMarkdown,
+          ],
+          authToken: data.slackRequest.projectAuthToken!,
+          channelId: data.slackRequest.slackChannelId,
+          userId: data.slackRequest.slackUserId!,
+        });
+      }
+      return;
+    }
+
     const onCallPolicyDropdown: WorkspaceDropdownBlock = {
       _type: "WorkspaceDropdownBlock",
       label: "On Call Policy",