@oneuptime/common 9.5.9 → 9.5.12

package/Server/API/OpenSourceDeploymentAPI.ts

@@ -39,6 +39,14 @@ export default class OpenSourceDeploymentAPI extends BaseAPI<
             (body["oneuptimeVersion"] as string) || "unknown";
           deployment.instanceUrl = (body["instanceUrl"] as string) || "";
 
+          // Skip localhost instances - these are default/unconfigured deployments.
+          if (
+            deployment.instanceUrl === "http://localhost/" ||
+            deployment.instanceUrl === "http://localhost"
+          ) {
+            return Response.sendEmptySuccessResponse(req, res);
+          }
+
           await OpenSourceDeploymentService.create({
             data: deployment,
             props: {

package/Server/Middleware/UserAuthorization.ts

@@ -177,10 +177,15 @@ export default class UserMiddleware {
     try {
       oneuptimeRequest.userAuthorization = JSONWebToken.decode(accessToken);
     } catch (err) {
-      // if the token is invalid or expired, it'll throw this error.
+      // if the token is invalid or expired, return 401 so clients can refresh the token.
       logger.error(err);
-      oneuptimeRequest.userType = UserType.Public;
-      return next();
+      return Response.sendErrorResponse(
+        req,
+        res,
+        new NotAuthenticatedException(
+          "AccessToken is invalid or expired. Please refresh your token.",
+        ),
+      );
     }
 
     if (oneuptimeRequest.userAuthorization.isMasterAdmin) {

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

@@ -1805,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/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/Slack.ts

@@ -442,12 +442,14 @@ export default class SlackUtil extends WorkspaceBase {
     const workspaceChannels: Array<WorkspaceChannel> = [];
 
     for (let channelName of data.channelNames) {
-      // Normalize channel name
-      if (channelName && channelName.startsWith("#")) {
-        channelName = channelName.substring(1);
-      }
-      channelName = channelName.toLowerCase();
-      channelName = channelName.replace(/\s+/g, "-");
+      /*
+       * Normalize channel name: replace spaces with hyphens, then strip
+       * any characters not valid in Slack channel names.
+       */
+      channelName = channelName
+        .toLowerCase()
+        .replace(/\s+/g, "-")
+        .replace(/[^a-z0-9\-_]/g, "");
 
       // Check if channel exists using optimized method
       const existingChannel: WorkspaceChannel | null =
@@ -1345,12 +1347,13 @@ export default class SlackUtil extends WorkspaceBase {
     channelName: string;
     projectId: ObjectID;
   }): Promise<WorkspaceChannel> {
-    if (data.channelName && data.channelName.startsWith("#")) {
-      data.channelName = data.channelName.substring(1);
-    }
-
-    // lower case channel name
-    data.channelName = data.channelName.toLowerCase();
+    /*
+     * Sanitize channel name: Slack only allows lowercase letters, numbers,
+     * hyphens, and underscores. Remove all other characters (including #).
+     */
+    data.channelName = data.channelName
+      .toLowerCase()
+      .replace(/[^a-z0-9\-_]/g, "");
 
     logger.debug("Creating channel with data:");
     logger.debug(data);

package/Tests/Server/Middleware/UserAuthorization.test.ts

@@ -14,6 +14,7 @@ import Response from "../../../Server/Utils/Response";
 import Dictionary from "../../../Types/Dictionary";
 import Email from "../../../Types/Email";
 import BadDataException from "../../../Types/Exception/BadDataException";
+import NotAuthenticatedException from "../../../Types/Exception/NotAuthenticatedException";
 import SsoAuthorizationException from "../../../Types/Exception/SsoAuthorizationException";
 import HashedString from "../../../Types/HashedString";
 import JSONFunctions from "../../../Types/JSONFunctions";
@@ -330,7 +331,7 @@ describe("UserMiddleware", () => {
       expect(JSONWebToken.decode).not.toHaveBeenCalled();
     });
 
-    test("should call function 'next' and return, when accessToken can not be decoded", async () => {
+    test("should call Response.sendErrorResponse with NotAuthenticatedException, when accessToken can not be decoded", async () => {
       const error: Error = new Error("Invalid access token");
 
       const spyJWTDecode: jest.SpyInstance = getJestSpyOn(
@@ -342,7 +343,14 @@ describe("UserMiddleware", () => {
 
       await UserMiddleware.getUserMiddleware(req, res, next);
 
-      expect(next).toHaveBeenCalled();
+      expect(Response.sendErrorResponse).toHaveBeenCalledWith(
+        req,
+        res,
+        new NotAuthenticatedException(
+          "AccessToken is invalid or expired. Please refresh your token.",
+        ),
+      );
+      expect(next).not.toHaveBeenCalled();
       expect(spyJWTDecode).toHaveBeenCalledWith(mockedAccessToken);
       expect(UserService.updateOneBy).not.toHaveBeenCalled();
     });

package/Types/Monitor/CriteriaFilter.ts

@@ -60,6 +60,13 @@ export enum CheckOn {
   SnmpOidExists = "SNMP OID Exists",
   SnmpResponseTime = "SNMP Response Time (in ms)",
   SnmpIsOnline = "SNMP Device Is Online",
+
+  // DNS monitors.
+  DnsResponseTime = "DNS Response Time (in ms)",
+  DnsIsOnline = "DNS Is Online",
+  DnsRecordValue = "DNS Record Value",
+  DnssecIsValid = "DNSSEC Is Valid",
+  DnsRecordExists = "DNS Record Exists",
 }
 
 export interface ServerMonitorOptions {
@@ -141,7 +148,11 @@ export class CriteriaFilterUtil {
   }): boolean {
     const { checkOn } = data;
 
-    if (checkOn === CheckOn.IsOnline || checkOn === CheckOn.SnmpIsOnline) {
+    if (
+      checkOn === CheckOn.IsOnline ||
+      checkOn === CheckOn.SnmpIsOnline ||
+      checkOn === CheckOn.DnsIsOnline
+    ) {
       return false;
     }
 
@@ -149,7 +160,11 @@ export class CriteriaFilterUtil {
       return false;
     }
 
-    if (checkOn === CheckOn.SnmpOidExists) {
+    if (
+      checkOn === CheckOn.SnmpOidExists ||
+      checkOn === CheckOn.DnssecIsValid ||
+      checkOn === CheckOn.DnsRecordExists
+    ) {
       return false;
     }
 
@@ -204,7 +219,9 @@ export class CriteriaFilterUtil {
       checkOn === CheckOn.MemoryUsagePercent ||
       checkOn === CheckOn.IsOnline ||
       checkOn === CheckOn.SnmpResponseTime ||
-      checkOn === CheckOn.SnmpIsOnline
+      checkOn === CheckOn.SnmpIsOnline ||
+      checkOn === CheckOn.DnsResponseTime ||
+      checkOn === CheckOn.DnsIsOnline
     );
   }
 }

package/Types/Monitor/DnsMonitor/DnsMonitorResponse.ts

@@ -0,0 +1,16 @@
+import DnsRecordType from "./DnsRecordType";
+
+export interface DnsRecordResponse {
+  type: DnsRecordType;
+  value: string;
+  ttl?: number | undefined;
+}
+
+export default interface DnsMonitorResponse {
+  isOnline: boolean;
+  responseTimeInMs: number;
+  failureCause: string;
+  records: Array<DnsRecordResponse>;
+  isDnssecValid?: boolean | undefined;
+  isTimeout?: boolean | undefined;
+}

package/Types/Monitor/DnsMonitor/DnsRecordType.ts

@@ -0,0 +1,14 @@
+enum DnsRecordType {
+  A = "A",
+  AAAA = "AAAA",
+  CNAME = "CNAME",
+  MX = "MX",
+  NS = "NS",
+  TXT = "TXT",
+  SOA = "SOA",
+  PTR = "PTR",
+  SRV = "SRV",
+  CAA = "CAA",
+}
+
+export default DnsRecordType;

package/Types/Monitor/MonitorCriteriaInstance.ts

@@ -394,6 +394,33 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
       return monitorCriteriaInstance;
     }
 
+    if (arg.monitorType === MonitorType.DNS) {
+      const monitorCriteriaInstance: MonitorCriteriaInstance =
+        new MonitorCriteriaInstance();
+
+      monitorCriteriaInstance.data = {
+        id: ObjectID.generate().toString(),
+        monitorStatusId: arg.monitorStatusId,
+        filterCondition: FilterCondition.All,
+        filters: [
+          {
+            checkOn: CheckOn.DnsIsOnline,
+            filterType: FilterType.True,
+            value: undefined,
+          },
+        ],
+        incidents: [],
+        alerts: [],
+        createAlerts: false,
+        changeMonitorStatus: true,
+        createIncidents: false,
+        name: `Check if ${arg.monitorName} is online`,
+        description: `This criteria checks if the ${arg.monitorName} DNS resolution is online`,
+      };
+
+      return monitorCriteriaInstance;
+    }
+
     return null;
   }
 
@@ -495,6 +522,46 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
       };
     }
 
+    if (arg.monitorType === MonitorType.DNS) {
+      monitorCriteriaInstance.data = {
+        id: ObjectID.generate().toString(),
+        monitorStatusId: arg.monitorStatusId,
+        filterCondition: FilterCondition.Any,
+        filters: [
+          {
+            checkOn: CheckOn.DnsIsOnline,
+            filterType: FilterType.False,
+            value: undefined,
+          },
+        ],
+        incidents: [
+          {
+            title: `${arg.monitorName} is offline`,
+            description: `${arg.monitorName} DNS resolution is currently failing.`,
+            incidentSeverityId: arg.incidentSeverityId,
+            autoResolveIncident: true,
+            id: ObjectID.generate().toString(),
+            onCallPolicyIds: [],
+          },
+        ],
+        changeMonitorStatus: true,
+        createIncidents: true,
+        createAlerts: false,
+        alerts: [
+          {
+            title: `${arg.monitorName} is offline`,
+            description: `${arg.monitorName} DNS resolution is currently failing.`,
+            alertSeverityId: arg.alertSeverityId,
+            autoResolveAlert: true,
+            id: ObjectID.generate().toString(),
+            onCallPolicyIds: [],
+          },
+        ],
+        name: `Check if ${arg.monitorName} is offline`,
+        description: `This criteria checks if the ${arg.monitorName} DNS resolution is failing`,
+      };
+    }
+
     if (
       arg.monitorType === MonitorType.API ||
       arg.monitorType === MonitorType.Website