@oneuptime/common 8.0.5514 → 8.0.5544

package/Models/DatabaseModels/AcmeChallenge.ts

@@ -4,11 +4,13 @@ import ColumnAccessControl from "../../Types/Database/AccessControl/ColumnAccess
 import TableAccessControl from "../../Types/Database/AccessControl/TableAccessControl";
 import ColumnLength from "../../Types/Database/ColumnLength";
 import ColumnType from "../../Types/Database/ColumnType";
+import CrudApiEndpoint from "../../Types/Database/CrudApiEndpoint";
 import TableColumn from "../../Types/Database/TableColumn";
 import TableColumnType from "../../Types/Database/TableColumnType";
 import TableMetadata from "../../Types/Database/TableMetadata";
 import IconProp from "../../Types/Icon/IconProp";
 import ObjectID from "../../Types/ObjectID";
+import Route from "../../Types/API/Route";
 import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
 
 @TableAccessControl({
@@ -24,6 +26,7 @@ import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
   icon: IconProp.Lock,
   tableDescription: "HTTP Challege for Lets Encrypt Certificates",
 })
+@CrudApiEndpoint(new Route("/acme-challenge"))
 @Entity({
   name: "AcmeChallenge",
 })

package/Models/DatabaseModels/Domain.ts

@@ -301,7 +301,12 @@ export default class Domain extends BaseModel {
   public deletedByUserId?: ObjectID = undefined;
 
   @ColumnAccessControl({
-    create: [],
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateProjectDomain,
+    ],
     read: [
       Permission.ProjectOwner,
       Permission.ProjectAdmin,

package/Server/API/AcmeChallengeAPI.ts

@@ -0,0 +1,64 @@
+import AcmeChallenge from "../../Models/DatabaseModels/AcmeChallenge";
+import NotFoundException from "../../Types/Exception/NotFoundException";
+import AcmeChallengeService, {
+  Service as AcmeChallengeServiceType,
+} from "../Services/AcmeChallengeService";
+import Express, {
+  ExpressRequest,
+  ExpressResponse,
+  ExpressRouter,
+  NextFunction,
+} from "../Utils/Express";
+import Response from "../Utils/Response";
+import BaseAPI from "./BaseAPI";
+
+export default class AcmeChallengeAPI extends BaseAPI<
+  AcmeChallenge,
+  AcmeChallengeServiceType
+> {
+  private wellKnownRouter: ExpressRouter;
+
+  public constructor() {
+    super(AcmeChallenge, AcmeChallengeService);
+
+    this.wellKnownRouter = Express.getRouter();
+
+    this.wellKnownRouter.get(
+      "/acme-challenge/.well-known/:token",
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const challenge: AcmeChallenge | null =
+            await AcmeChallengeService.findOneBy({
+              query: {
+                token: req.params["token"] as string,
+              },
+              select: {
+                challenge: true,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+          if (!challenge) {
+            return next(new NotFoundException("Challenge not found"));
+          }
+
+          return Response.sendTextResponse(
+            req,
+            res,
+            challenge.challenge as string,
+          );
+        } catch (err) {
+          return next(err);
+        }
+      },
+    );
+
+    this.router.use("/", this.wellKnownRouter);
+  }
+
+  public getWellKnownRouter(): ExpressRouter {
+    return this.wellKnownRouter;
+  }
+}

package/Server/EnvironmentConfig.ts

@@ -23,6 +23,58 @@ export const getAllEnvVars: () => JSONObject = (): JSONObject => {
   return process.env;
 };
 
+const FRONTEND_ENV_ALLOW_LIST: Array<string> = [
+  "NODE_ENV",
+  "HTTP_PROTOCOL",
+  "HOST",
+  "BILLING_ENABLED",
+  "BILLING_PUBLIC_KEY",
+  "IS_ENTERPRISE_EDITION",
+  "STRIPE_PUBLIC_KEY",
+  "VAPID_PUBLIC_KEY",
+  "VAPID_SUBJECT",
+  "VERSION",
+  "STATUS_PAGE_CNAME_RECORD",
+  "ANALYTICS_KEY",
+  "ANALYTICS_HOST",
+  "GIT_SHA",
+  "APP_VERSION",
+  "OPENTELEMETRY_EXPORTER_OTLP_ENDPOINT",
+  "OPENTELEMETRY_EXPORTER_OTLP_HEADERS",
+  "DISABLE_TELEMETRY",
+  "SLACK_APP_CLIENT_ID",
+  "MICROSOFT_TEAMS_APP_CLIENT_ID",
+];
+
+const FRONTEND_ENV_ALLOW_PREFIXES: Array<string> = [
+  "SUBSCRIPTION_PLAN_",
+  "PUBLIC_",
+];
+
+export const getFrontendEnvVars: () => JSONObject = (): JSONObject => {
+  const frontendEnv: JSONObject = {};
+
+  for (const key of Object.keys(process.env)) {
+    const shouldInclude: boolean =
+      FRONTEND_ENV_ALLOW_LIST.includes(key) ||
+      FRONTEND_ENV_ALLOW_PREFIXES.some((prefix: string) => {
+        return key.startsWith(prefix);
+      });
+
+    if (!shouldInclude) {
+      continue;
+    }
+
+    const value: string | undefined = process.env[key];
+
+    if (typeof value !== "undefined") {
+      frontendEnv[key] = value;
+    }
+  }
+
+  return frontendEnv;
+};
+
 const parsePositiveNumberFromEnv: (
   envKey: string,
   fallback: number,
@@ -276,6 +328,8 @@ export const HttpProtocol: Protocol =
 
 export const Host: string = process.env["HOST"] || "";
 
+export const ProvisionSsl: boolean = process.env["PROVISION_SSL"] === "true";
+
 export const WorkflowScriptTimeoutInMS: number = process.env[
   "WORKFLOW_SCRIPT_TIMEOUT_IN_MS"
 ]

package/Server/Infrastructure/Queue.ts

@@ -1,9 +1,4 @@
-import {
-  ClusterKey,
-  RedisHostname,
-  RedisPassword,
-  RedisPort,
-} from "../EnvironmentConfig";
+import { ClusterKey } from "../EnvironmentConfig";
 import Dictionary from "../../Types/Dictionary";
 import { JSONObject } from "../../Types/JSON";
 import { Queue as BullQueue, Job, JobsOptions } from "bullmq";
@@ -13,6 +8,7 @@ import { BullMQAdapter } from "@bull-board/api/bullMQAdapter";
 import { ExpressRouter } from "../Utils/Express";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger from "../Utils/Logger";
+import Redis from "./Redis";
 
 export enum QueueName {
   Workflow = "Workflow",
@@ -25,6 +21,7 @@ export enum QueueName {
 }
 
 export type QueueJob = Job;
+type BullBoardQueues = Parameters<typeof createBullBoard>[0]["queues"];
 
 export default class Queue {
   private static queueDict: Dictionary<BullQueue> = {};
@@ -82,11 +79,7 @@ export default class Queue {
     }
 
     const queue: BullQueue = new BullQueue(queueName, {
-      connection: {
-        host: RedisHostname.toString(),
-        port: RedisPort.toNumber(),
-        password: RedisPassword,
-      },
+      connection: Redis.getRedisOptions(),
       // Keep BullMQ data under control to avoid Redis bloat
       defaultJobOptions: {
         // keep only recent completed/failed jobs
@@ -157,12 +150,15 @@ export default class Queue {
   public static getQueueInspectorRouter(): ExpressRouter {
     const serverAdapter: ExpressAdapter = new ExpressAdapter();
 
+    const queueAdapters: BullMQAdapter[] = Object.values(QueueName).map(
+      (queueName: QueueName) => {
+        return new BullMQAdapter(this.getQueue(queueName));
+      },
+    );
+
     createBullBoard({
-      queues: [
-        ...Object.values(QueueName).map((queueName: QueueName) => {
-          return new BullMQAdapter(this.getQueue(queueName));
-        }),
-      ],
+      // Cast keeps compatibility until bull-board widens QueueJob.progress
+      queues: queueAdapters as unknown as BullBoardQueues,
       serverAdapter: serverAdapter,
     });
 

package/Server/Infrastructure/QueueWorker.ts

@@ -1,4 +1,3 @@
-import { RedisHostname, RedisPassword, RedisPort } from "../EnvironmentConfig";
 import { QueueJob, QueueName } from "./Queue";
 import TimeoutException from "../../Types/Exception/TimeoutException";
 import {
@@ -8,6 +7,7 @@ import {
 } from "../../Types/FunctionTypes";
 import { Worker } from "bullmq";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import Redis from "./Redis";
 
 export default class QueueWorker {
   @CaptureSpan()
@@ -30,11 +30,7 @@ export default class QueueWorker {
     },
   ): Worker {
     const worker: Worker = new Worker(queueName, onJobInQueue, {
-      connection: {
-        host: RedisHostname.toString(),
-        port: RedisPort.toNumber(),
-        password: RedisPassword,
-      },
+      connection: Redis.getRedisOptions(),
       concurrency: options.concurrency,
       // Only set these values if provided so we do not override BullMQ defaults
       ...(options.lockDuration ? { lockDuration: options.lockDuration } : {}),

package/Server/Services/DomainService.ts

@@ -7,6 +7,9 @@ import BadDataException from "../../Types/Exception/BadDataException";
 import Text from "../../Types/Text";
 import Model from "../../Models/DatabaseModels/Domain";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import ObjectID from "../../Types/ObjectID";
+import { FindWhere } from "../../Types/BaseDatabase/Query";
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
@@ -32,6 +35,12 @@ export class Service extends DatabaseService<Model> {
       createBy.data.domain = new Domain(domain.trim().toLowerCase());
     }
 
+    if (!createBy.props.isRoot && createBy.data.isVerified) {
+      throw new BadDataException(
+        "Domain cannot be verified during creation. Please verify the domain after creation. Please set isVerified to false.",
+      );
+    }
+
     createBy.data.domainVerificationText =
       "oneuptime-verification-" + Text.generateRandomText(20);
     return Promise.resolve({ createBy, carryForward: null });
@@ -41,67 +50,66 @@ export class Service extends DatabaseService<Model> {
   protected override async onBeforeUpdate(
     updateBy: UpdateBy<Model>,
   ): Promise<OnUpdate<Model>> {
-    if (
-      updateBy.data.isVerified &&
-      updateBy.query._id &&
-      !updateBy.props.isRoot
-    ) {
+    if (updateBy.data.isVerified && !updateBy.props.isRoot) {
+      const projectId: FindWhere<ObjectID> | undefined =
+        updateBy.query.projectId || updateBy.props.tenantId;
+
+      if (!projectId) {
+        throw new BadDataException(
+          "Project ID is required to verify the domain.",
+        );
+      }
+
       // check the verification of the domain.
 
       const items: Array<Model> = await this.findBy({
         query: {
-          _id: updateBy.query._id as string,
-          projectId: updateBy.props.tenantId!,
+          projectId,
+          ...updateBy.query,
         },
         select: {
           domain: true,
           domainVerificationText: true,
         },
 
-        limit: 1,
+        limit: LIMIT_PER_PROJECT,
         skip: 0,
         props: {
           isRoot: true,
         },
       });
 
-      if (items.length === 0) {
-        throw new BadDataException(
-          "Domain with id " + updateBy.query._id + " not found.",
-        );
-      }
+      for (const item of items) {
+        const domain: string | undefined = item?.domain?.toString();
+        const verificationText: string | undefined =
+          item?.domainVerificationText?.toString();
 
-      const domain: string | undefined = items[0]?.domain?.toString();
-      const verificationText: string | undefined =
-        items[0]?.domainVerificationText?.toString();
+        if (!domain) {
+          throw new BadDataException("Domain not found.");
+        }
 
-      if (!domain) {
-        throw new BadDataException(
-          "Domain with id " + updateBy.query._id + " not found.",
-        );
-      }
+        if (!verificationText) {
+          throw new BadDataException(
+            "Domain verification text with id " +
+              updateBy.query._id +
+              " not found.",
+          );
+        }
 
-      if (!verificationText) {
-        throw new BadDataException(
-          "Domain verification text with id " +
-            updateBy.query._id +
-            " not found.",
+        const isVerified: boolean = await Domain.verifyTxtRecord(
+          domain,
+          verificationText,
         );
-      }
-
-      const isVerified: boolean = await Domain.verifyTxtRecord(
-        domain,
-        verificationText,
-      );
 
-      if (!isVerified) {
-        throw new BadDataException(
-          "Verification TXT record " +
-            verificationText +
-            " not found in domain " +
-            domain +
-            ". Please add a TXT record to verify the domain. If you have already added the TXT record, please wait for few hours to let DNS to propagate.",
-        );
+        if (!isVerified) {
+          throw new BadDataException(
+            "Verification TXT record " +
+              verificationText +
+              " not found in domain " +
+              domain +
+              ". Please add a TXT record to verify the domain. If you have already added the TXT record, please wait for few hours to let DNS to propagate.",
+          );
+        }
       }
     }
 

package/Server/Utils/AnalyticsDatabase/Statement.ts

@@ -177,11 +177,15 @@ export class Statement implements BaseQueryParams {
     };
 
     if ((statementParam as StatementParameter).value instanceof Includes) {
-      const isNumberArray: boolean = (
+      const includesValues: Array<string | number | ObjectID> = (
         (statementParam as StatementParameter).value as Includes
-      ).values.every((v: string | number | ObjectID) => {
-        return typeof v === "number";
-      });
+      ).values as Array<string | number | ObjectID>;
+
+      const isNumberArray: boolean = includesValues.every(
+        (v: string | number | ObjectID) => {
+          return typeof v === "number";
+        },
+      );
 
       if (isNumberArray) {
         return "Array(Int32)";

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

@@ -563,39 +563,39 @@ export default class CompareCriteria {
       data.criteriaFilter.filterType !== FilterType.True &&
       data.criteriaFilter.filterType !== FilterType.False
     ) {
-      if (Array.isArray(data.values)) {
-        message += ` is ${data.values.join(", ")}`;
-      } else {
-        message += ` is ${data.values}`;
-      }
+      const formattedValues: string = CompareCriteria.formatCriteriaValues(
+        data.values,
+      );
+
+      message += ` is ${formattedValues}`;
 
       message += " which is";
     }
 
     switch (data.criteriaFilter.filterType) {
       case FilterType.GreaterThan:
-        message += ` greater than ${data.threshold}. `;
+        message += ` greater than ${CompareCriteria.formatSingleValue(data.threshold)}. `;
         break;
       case FilterType.GreaterThanOrEqualTo:
-        message += ` greater than or equal to ${data.threshold}. `;
+        message += ` greater than or equal to ${CompareCriteria.formatSingleValue(data.threshold)}. `;
         break;
       case FilterType.LessThan:
-        message += ` less than ${data.threshold}. `;
+        message += ` less than ${CompareCriteria.formatSingleValue(data.threshold)}. `;
         break;
       case FilterType.LessThanOrEqualTo:
-        message += ` less than or equal to ${data.threshold}. `;
+        message += ` less than or equal to ${CompareCriteria.formatSingleValue(data.threshold)}. `;
         break;
       case FilterType.NotEqualTo:
-        message += ` not equal to ${data.threshold}. `;
+        message += ` not equal to ${CompareCriteria.formatSingleValue(data.threshold)}. `;
         break;
       case FilterType.EqualTo:
-        message += ` equal to ${data.threshold}. `;
+        message += ` equal to ${CompareCriteria.formatSingleValue(data.threshold)}. `;
         break;
       case FilterType.Contains:
-        message += ` contains ${data.threshold}. `;
+        message += ` contains ${CompareCriteria.formatSingleValue(data.threshold)}. `;
         break;
       case FilterType.NotContains:
-        message += ` does not contain ${data.threshold}. `;
+        message += ` does not contain ${CompareCriteria.formatSingleValue(data.threshold)}. `;
         break;
       case FilterType.True:
         message += ` is ${data.threshold}. `;
@@ -604,13 +604,45 @@ export default class CompareCriteria {
         message += ` is ${data.threshold}. `;
         break;
       case FilterType.StartsWith:
-        message += ` starts with ${data.threshold}. `;
+        message += ` starts with ${CompareCriteria.formatSingleValue(data.threshold)}. `;
         break;
       case FilterType.EndsWith:
-        message += ` ends with ${data.threshold}. `;
+        message += ` ends with ${CompareCriteria.formatSingleValue(data.threshold)}. `;
         break;
     }
 
     return message.trim();
   }
+
+  private static formatCriteriaValues(
+    values: Array<number | boolean> | number | boolean | string,
+  ): string {
+    if (Array.isArray(values)) {
+      return values
+        .map((value: number | boolean) => {
+          return CompareCriteria.formatSingleValue(value);
+        })
+        .join(", ");
+    }
+
+    return CompareCriteria.formatSingleValue(values);
+  }
+
+  private static formatSingleValue(
+    value: number | boolean | string | null | undefined,
+  ): string {
+    if (value === null || value === undefined) {
+      return "unknown";
+    }
+
+    if (typeof value === Typeof.Number) {
+      return (value as number).toFixed(2);
+    }
+
+    if (typeof value === Typeof.Boolean) {
+      return value ? "true" : "false";
+    }
+
+    return value.toString();
+  }
 }

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

@@ -169,20 +169,21 @@ export default class ServerMonitorCriteria {
       const diskPath: string =
         input.criteriaFilter.serverMonitorOptions?.diskPath || "/";
 
-      const diskPercent: number =
-        (
-          input.dataToProcess as ServerMonitorResponse
-        ).basicInfrastructureMetrics?.diskMetrics.filter(
-          (item: BasicDiskMetrics) => {
-            return (
-              item.diskPath.trim().toLowerCase() ===
-              diskPath.trim().toLowerCase()
-            );
-          },
-        )[0]?.percentFree || 0;
+      const diskMetric: BasicDiskMetrics | undefined = (
+        input.dataToProcess as ServerMonitorResponse
+      ).basicInfrastructureMetrics?.diskMetrics.find(
+        (item: BasicDiskMetrics) => {
+          return (
+            item.diskPath.trim().toLowerCase() === diskPath.trim().toLowerCase()
+          );
+        },
+      );
+
+      const diskUsagePercent: number =
+        diskMetric?.percentUsed ?? diskMetric?.percentFree ?? 0;
 
       return CompareCriteria.compareCriteriaNumbers({
-        value: diskPercent,
+        value: diskUsagePercent,
         threshold: threshold as number,
         criteriaFilter: input.criteriaFilter,
       });

package/Server/Utils/Monitor/MonitorAlert.ts

@@ -21,6 +21,8 @@ import CaptureSpan from "../Telemetry/CaptureSpan";
 import DataToProcess from "./DataToProcess";
 import MonitorTemplateUtil from "./MonitorTemplateUtil";
 import { JSONObject } from "../../../Types/JSON";
+import OneUptimeDate from "../../../Types/Date";
+import MonitorEvaluationSummary from "../../../Types/Monitor/MonitorEvaluationSummary";
 
 export default class MonitorAlert {
   @CaptureSpan()
@@ -30,6 +32,7 @@ export default class MonitorAlert {
     rootCause: string;
     criteriaInstance: MonitorCriteriaInstance | null;
     dataToProcess: DataToProcess;
+    evaluationSummary?: MonitorEvaluationSummary | undefined;
   }): Promise<Array<Alert>> {
     // check active alerts and if there are open alerts, do not cretae anothr alert.
     const openAlerts: Array<Alert> = await AlertService.findBy({
@@ -45,6 +48,7 @@ export default class MonitorAlert {
         _id: true,
         createdCriteriaId: true,
         projectId: true,
+        alertNumber: true,
       },
       props: {
         isRoot: true,
@@ -68,6 +72,17 @@ export default class MonitorAlert {
           rootCause: input.rootCause,
           dataToProcess: input.dataToProcess,
         });
+
+        input.evaluationSummary?.events.push({
+          type: "alert-resolved",
+          title: `Alert resolved: ${openAlert.id?.toString()}`,
+          message:
+            "Alert auto-resolved because autoresolve is enabled for this criteria.",
+          relatedAlertId: openAlert.id?.toString(),
+          relatedAlertNumber: openAlert.alertNumber,
+          relatedCriteriaId: input.criteriaInstance?.data?.id,
+          at: OneUptimeDate.getCurrentDate(),
+        });
       }
     }
 
@@ -81,6 +96,7 @@ export default class MonitorAlert {
     dataToProcess: DataToProcess;
     rootCause: string;
     autoResolveCriteriaInstanceIdAlertIdsDictionary: Dictionary<Array<string>>;
+    evaluationSummary?: MonitorEvaluationSummary | undefined;
     props: {
       telemetryQuery?: TelemetryQuery | undefined;
     };
@@ -96,6 +112,7 @@ export default class MonitorAlert {
         rootCause: input.rootCause,
         criteriaInstance: input.criteriaInstance,
         dataToProcess: input.dataToProcess,
+        evaluationSummary: input.evaluationSummary,
       });
 
     if (input.criteriaInstance.data?.createAlerts) {
@@ -124,6 +141,16 @@ export default class MonitorAlert {
         );
 
         if (hasAlreadyOpenAlert) {
+          input.evaluationSummary?.events.push({
+            type: "alert-skipped",
+            title: `Alert already active: ${criteriaAlert.title}`,
+            message:
+              "Skipped creating a new alert because an active alert exists for this criteria.",
+            relatedCriteriaId: input.criteriaInstance.data?.id,
+            relatedAlertId: alreadyOpenAlert?.id?.toString(),
+            relatedAlertNumber: alreadyOpenAlert?.alertNumber,
+            at: OneUptimeDate.getCurrentDate(),
+          });
           continue;
         }
 
@@ -214,15 +241,33 @@ export default class MonitorAlert {
         }
 
         if (DisableAutomaticAlertCreation) {
+          input.evaluationSummary?.events.push({
+            type: "alert-skipped",
+            title: "Alert creation skipped",
+            message:
+              "Automatic alert creation is disabled by environment configuration.",
+            relatedCriteriaId: input.criteriaInstance.data?.id,
+            at: OneUptimeDate.getCurrentDate(),
+          });
           return;
         }
 
-        await AlertService.create({
+        const createdAlert: Alert = await AlertService.create({
           data: alert,
           props: {
             isRoot: true,
           },
         });
+
+        input.evaluationSummary?.events.push({
+          type: "alert-created",
+          title: `Alert created: ${createdAlert.title || criteriaAlert.title}`,
+          message: `Alert triggered from criteria "${input.criteriaInstance.data?.name || "Unnamed criteria"}".`,
+          relatedCriteriaId: input.criteriaInstance.data?.id,
+          relatedAlertId: createdAlert.id?.toString(),
+          relatedAlertNumber: createdAlert.alertNumber,
+          at: OneUptimeDate.getCurrentDate(),
+        });
       }
     }
   }