@oneuptime/common 14.0.13 → 14.0.14

package/Models/DatabaseModels/TraceScrubRule.ts

@@ -18,6 +18,7 @@ import IconProp from "../../Types/Icon/IconProp";
 import ObjectID from "../../Types/ObjectID";
 import Permission from "../../Types/Permission";
 import { PlanType } from "../../Types/Billing/SubscriptionPlan";
+import { TRACE_SCRUB_RULE_DEFAULTS } from "../../Types/Telemetry/ScrubRule";
 import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
 
 @EnableDocumentation()
@@ -241,7 +242,7 @@ export default class TraceScrubRule extends BaseModel {
     canReadOnRelationQuery: true,
     title: "Pattern Type",
     description:
-      "The type of sensitive data pattern to detect: email, creditCard, ssn, phoneNumber, ipAddress, or custom.",
+      "The type of sensitive data to detect: email, creditCard, ssn, phoneNumber, ipAddress, sensitiveKeys (the whole value of every attribute whose key looks sensitive, such as password or token), or custom (the regular expression in customRegex). Any other value is refused: it would scrub nothing.",
   })
   @Column({
     nullable: false,
@@ -278,7 +279,7 @@ export default class TraceScrubRule extends BaseModel {
     canReadOnRelationQuery: true,
     title: "Custom Regex",
     description:
-      "A custom regular expression pattern to match. Only used when patternType is 'custom'.",
+      "The regular expression a 'custom' rule scrubs, written without slashes or flags and matched case-sensitively. Required when patternType is 'custom': a pattern that is empty, does not compile, or matches empty text is refused. Ignored for the other pattern types.",
   })
   @Column({
     nullable: true,
@@ -315,13 +316,15 @@ export default class TraceScrubRule extends BaseModel {
     canReadOnRelationQuery: true,
     title: "Scrub Action",
     description:
-      "How to scrub matched data: 'mask' partially hides it, 'hash' replaces with a hash, 'redact' removes entirely.",
+      "How to scrub matched data: 'redact' replaces it with [REDACTED] (the default), 'mask' partially hides it, 'hash' replaces it with a short hash of the value.",
+    defaultValue: TRACE_SCRUB_RULE_DEFAULTS.scrubAction,
+    isDefaultValueColumn: true,
   })
   @Column({
     nullable: false,
     type: ColumnType.ShortText,
     length: ColumnLength.ShortText,
-    default: "redact",
+    default: TRACE_SCRUB_RULE_DEFAULTS.scrubAction,
   })
   public scrubAction?: string = undefined;
 
@@ -353,13 +356,15 @@ export default class TraceScrubRule extends BaseModel {
     canReadOnRelationQuery: true,
     title: "Fields to Scrub",
     description:
-      "Which span fields to scrub: 'name' (span name), 'attributes' (attribute values), 'events' (span event attributes), or 'all'.",
+      "Which span fields to scrub: 'name' (the span name), 'attributes' (attribute values), 'events' (span event attributes), or 'all', the default. A sensitiveKeys rule always scrubs attribute and event attribute values, whatever this says.",
+    defaultValue: TRACE_SCRUB_RULE_DEFAULTS.fieldsToScrub,
+    isDefaultValueColumn: true,
   })
   @Column({
     nullable: false,
     type: ColumnType.ShortText,
     length: ColumnLength.ShortText,
-    default: "all",
+    default: TRACE_SCRUB_RULE_DEFAULTS.fieldsToScrub,
   })
   public fieldsToScrub?: string = undefined;
 
@@ -392,12 +397,13 @@ export default class TraceScrubRule extends BaseModel {
     canReadOnRelationQuery: true,
     title: "Enabled",
     description: "Whether this scrub rule is active.",
-    defaultValue: true,
+    defaultValue: TRACE_SCRUB_RULE_DEFAULTS.isEnabled,
+    isDefaultValueColumn: true,
   })
   @Column({
     nullable: false,
     type: ColumnType.Boolean,
-    default: true,
+    default: TRACE_SCRUB_RULE_DEFAULTS.isEnabled,
   })
   public isEnabled?: boolean = undefined;
 

package/Models/DatabaseModels/UserOnCallLog.ts

@@ -885,7 +885,8 @@ export default class UserOnCallLog extends BaseModel {
     type: TableColumnType.Entity,
     modelType: User,
     title: "Overridden by User",
-    description: "Relation to User who overrode this alert",
+    description:
+      "The user this alert would have paged, when a user override sent it to this log's user instead because they were away. Empty when no override applied.",
   })
   @ManyToOne(
     () => {
@@ -909,7 +910,8 @@ export default class UserOnCallLog extends BaseModel {
   @TableColumn({
     type: TableColumnType.ObjectID,
     title: "Overridden by User ID",
-    description: "User ID who overrode this alert",
+    description:
+      "ID of the user this alert would have paged, when a user override sent it to this log's user instead because they were away. Empty when no override applied.",
     example: "7c9d8e0f-a1b2-4c3d-9e5f-8a7b9c0d1e2f",
   })
   @Column({

package/Server/API/CustomDomainRoutes.ts

@@ -0,0 +1,251 @@
+import UserMiddleware from "../Middleware/UserAuthorization";
+import DatabaseService from "../Services/DatabaseService";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  ExpressRouter,
+  NextFunction,
+} from "../Utils/Express";
+import Response from "../Utils/Response";
+import CommonAPI from "./CommonAPI";
+import BaseModel from "../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import Query from "../Types/Database/Query";
+import Select from "../Types/Database/Select";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import PositiveNumber from "../../Types/PositiveNumber";
+import CustomDomainVerification, {
+  CustomDomainVerificationResult,
+} from "../../Types/CustomDomain/CustomDomainVerification";
+import CustomDomainCertificates, {
+  CustomDomainCertificate,
+} from "../../Types/CustomDomain/CustomDomainCertificates";
+
+/*
+ * What the two routes need of a custom domain service beyond its table: a
+ * status page's (StatusPageDomainService) or a dashboard's
+ * (DashboardDomainService). Written as methods, so each service's own
+ * model type is accepted here.
+ */
+export interface CustomDomainRouteService {
+  isCnameValid(fullDomain: string): Promise<boolean>;
+  orderCertOnceCnameIsVerified(
+    domain: BaseModel,
+  ): Promise<CustomDomainVerificationResult>;
+  getCertificates(
+    domains: Array<BaseModel>,
+  ): Promise<Array<CustomDomainCertificate>>;
+}
+
+// What the routes read of a custom domain's row.
+interface CustomDomainRow {
+  fullDomain?: string | undefined;
+}
+
+/*
+ * The routes a Custom Domains page calls that the two kinds of custom domain
+ * share word for word - Check now and the Status column's certificates -
+ * registered once for both APIs, so the next fix to one is the fix to both.
+ * They used to be two copies, and the dashboard copy kept a Check now that
+ * only checked after the status page one learned to order.
+ */
+export default class CustomDomainRoutes {
+  public static add(data: {
+    router: ExpressRouter;
+    // The domain table's API path: "/status-page-domain", "/dashboard-domain".
+    crudApiPath: string;
+    service: DatabaseService<BaseModel> & CustomDomainRouteService;
+    /*
+     * What each domain's CNAME record must point to on this installation,
+     * read on every request. Empty where custom domains of this kind are off.
+     */
+    getCnameRecord: () => string;
+    // The column - and route parameter - naming the status page or dashboard.
+    parentColumn: string;
+  }): void {
+    const service: DatabaseService<BaseModel> & CustomDomainRouteService =
+      data.service;
+
+    /*
+     * CNAME verification: the domain's Check now button.
+     *
+     * The sweeps verify every domain every 15 minutes anyway; this is for the
+     * person who has just added the record and wants to know now. Once the
+     * record is found the domain's free certificate is ordered straight away
+     * (the service's orderCertOnceCnameIsVerified), and the answer says what
+     * happens to the certificate next.
+     */
+    data.router.get(
+      `${data.crudApiPath}/verify-cname/:id`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const cnameRecord: string = data.getCnameRecord();
+
+          if (!cnameRecord) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException(
+                "Custom Domains not enabled for this OneUptime installation. Please contact your server admin to enable this feature.",
+              ),
+            );
+          }
+
+          const idParameter: string = (req.params["id"] as string) || "";
+
+          // A malformed id is the caller's mistake, not a server error.
+          if (!ObjectID.isValidUUID(idParameter)) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("The domain ID is not valid."),
+            );
+          }
+
+          const databaseProps: DatabaseCommonInteractionProps =
+            await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+          const id: ObjectID = new ObjectID(idParameter);
+
+          // Whether the caller may read the domain, with their own props.
+          const domainCount: PositiveNumber = await service.countBy({
+            query: {
+              _id: id.toString(),
+            } as Query<BaseModel>,
+            props: databaseProps,
+          });
+
+          if (domainCount.toNumber() === 0) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException(
+                "The domain does not exist or user does not have access to it.",
+              ),
+            );
+          }
+
+          const domain: BaseModel | null = await service.findOneBy({
+            query: {
+              _id: id.toString(),
+            } as Query<BaseModel>,
+            select: {
+              _id: true,
+              fullDomain: true,
+              isCustomCertificate: true,
+              isSslOrdered: true,
+              // Whose on-demand orders the order counts against.
+              projectId: true,
+            } as Select<BaseModel>,
+            props: {
+              isRoot: true,
+            },
+          });
+
+          if (!domain) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("Invalid token."),
+            );
+          }
+
+          const fullDomain: string | undefined = (
+            domain as unknown as CustomDomainRow
+          ).fullDomain;
+
+          if (!fullDomain) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("Invalid domain."),
+            );
+          }
+
+          const isValid: boolean = await service.isCnameValid(fullDomain);
+
+          if (!isValid) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException(
+                `We could not find a CNAME record for ${fullDomain} that points to ${cnameRecord} yet. Please check the record at your DNS provider. A new record can take a while to show up, and we keep checking every 15 minutes.`,
+              ),
+            );
+          }
+
+          const result: CustomDomainVerificationResult =
+            await service.orderCertOnceCnameIsVerified(domain);
+
+          return Response.sendJsonObjectResponse(
+            req,
+            res,
+            CustomDomainVerification.toJSON(result),
+          );
+        } catch (e) {
+          next(e);
+        }
+      },
+    );
+
+    /*
+     * Where the certificates of a status page's or a dashboard's custom
+     * domains stand, for the Custom Domains page's Status column: each
+     * domain's certificate expiry, and why its last order failed while no
+     * order since has succeeded (CustomDomainCertificates). Neither is on the
+     * domain row, so without this an order that kept failing showed as
+     * "Issuing" for good.
+     *
+     * Reads only: the domains are looked up with the caller's own props, so
+     * a caller sees the domains they may read and nothing else.
+     */
+    data.router.get(
+      `${data.crudApiPath}/certificates/:${data.parentColumn}`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const parentParameter: string =
+            (req.params[data.parentColumn] as string) || "";
+
+          if (!ObjectID.isValidUUID(parentParameter)) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("The ID is not valid."),
+            );
+          }
+
+          const databaseProps: DatabaseCommonInteractionProps =
+            await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+          const domains: Array<BaseModel> = await service.findBy({
+            query: {
+              [data.parentColumn]: new ObjectID(parentParameter),
+            } as Query<BaseModel>,
+            select: {
+              _id: true,
+              fullDomain: true,
+            } as Select<BaseModel>,
+            limit: LIMIT_MAX,
+            skip: 0,
+            props: databaseProps,
+          });
+
+          const certificates: Array<CustomDomainCertificate> =
+            await service.getCertificates(domains);
+
+          return Response.sendJsonObjectResponse(
+            req,
+            res,
+            CustomDomainCertificates.toJSON(certificates),
+          );
+        } catch (e) {
+          next(e);
+        }
+      },
+    );
+  }
+}

package/Server/API/DashboardAPI.ts

@@ -22,6 +22,13 @@ import ObjectID from "../../Types/ObjectID";
 import Dashboard from "../../Models/DatabaseModels/Dashboard";
 import DashboardDomain from "../../Models/DatabaseModels/DashboardDomain";
 import { DASHBOARD_MASTER_PASSWORD_INVALID_MESSAGE } from "../../Types/Dashboard/MasterPassword";
+import {
+  DashboardAccessState,
+  DashboardAccessSwitches,
+  isDashboardLockedWithoutPassword,
+  isDashboardMasterPasswordRequired,
+  isDashboardPublic,
+} from "../../Types/Dashboard/DashboardAccess";
 import NotAuthenticatedException from "../../Types/Exception/NotAuthenticatedException";
 import ForbiddenException from "../../Types/Exception/ForbiddenException";
 import JSONFunctions from "../../Types/JSONFunctions";
@@ -701,12 +708,24 @@ export default class DashboardAPI extends BaseAPI<
             throw new NotFoundException("Dashboard not found");
           }
 
+          /*
+           * Whether the public link asks for the password, by the rule the
+           * server enforces (Types/Dashboard/DashboardAccess): the effective
+           * value, not the stored switch - a private dashboard's switch does
+           * nothing.
+           */
+          const accessSwitches: DashboardAccessSwitches = {
+            isPublicDashboard: dashboard.isPublicDashboard,
+            enableMasterPassword: dashboard.enableMasterPassword,
+          };
+
           return Response.sendJsonObjectResponse(req, res, {
             _id: dashboard._id?.toString() || "",
             name: dashboard.name || "Dashboard",
             description: dashboard.description || "",
-            isPublicDashboard: dashboard.isPublicDashboard || false,
-            enableMasterPassword: dashboard.enableMasterPassword || false,
+            isPublicDashboard: isDashboardPublic(accessSwitches),
+            enableMasterPassword:
+              isDashboardMasterPasswordRequired(accessSwitches),
             pageTitle: dashboard.pageTitle || "",
             pageDescription: dashboard.pageDescription || "",
             logoFile: DashboardAPI.getFileAsBase64JSONObject(
@@ -1547,13 +1566,23 @@ export default class DashboardAPI extends BaseAPI<
             throw new NotFoundException("Dashboard not found");
           }
 
-          if (!dashboard.isPublicDashboard) {
+          // Who can view it, by the rule the Sharing page shows and writes.
+          const accessState: DashboardAccessState = {
+            isPublicDashboard: dashboard.isPublicDashboard,
+            enableMasterPassword: dashboard.enableMasterPassword,
+            hasMasterPassword: Boolean(dashboard.masterPassword),
+          };
+
+          if (!isDashboardPublic(accessState)) {
             throw new BadDataException(
               "This dashboard is not publicly accessible.",
             );
           }
 
-          if (!dashboard.enableMasterPassword || !dashboard.masterPassword) {
+          if (
+            !isDashboardMasterPasswordRequired(accessState) ||
+            isDashboardLockedWithoutPassword(accessState)
+          ) {
             throw new BadDataException(
               "Master password has not been configured for this dashboard.",
             );

package/Server/API/DashboardDomainAPI.ts

@@ -15,9 +15,12 @@ import BaseAPI from "./BaseAPI";
 import CommonAPI from "./CommonAPI";
 import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
 import BadDataException from "../../Types/Exception/BadDataException";
+import TooManyRequestsException from "../../Types/Exception/TooManyRequestsException";
 import ObjectID from "../../Types/ObjectID";
 import PositiveNumber from "../../Types/PositiveNumber";
 import DashboardDomain from "../../Models/DatabaseModels/DashboardDomain";
+import CertificateOrder from "../Utils/Greenlock/CertificateOrder";
+import CustomDomainRoutes from "./CustomDomainRoutes";
 
 export default class DashboardDomainAPI extends BaseAPI<
   DashboardDomain,
@@ -26,100 +29,37 @@ export default class DashboardDomainAPI extends BaseAPI<
   public constructor() {
     super(DashboardDomain, DashboardDomainService);
 
-    // CNAME verification api
-    this.router.get(
-      `${new this.entityType().getCrudApiPath()?.toString()}/verify-cname/:id`,
-      UserMiddleware.getUserMiddleware,
-      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
-        try {
-          if (!DashboardCNameRecord) {
-            return Response.sendErrorResponse(
-              req,
-              res,
-              new BadDataException(
-                `Custom Domains not enabled for this
-                                OneUptime installation. Please contact
-                                your server admin to enable this
-                                feature.`,
-              ),
-            );
-          }
-
-          const databaseProps: DatabaseCommonInteractionProps =
-            await CommonAPI.getDatabaseCommonInteractionProps(req);
-
-          const id: ObjectID = new ObjectID(req.params["id"] as string);
-
-          const domainCount: PositiveNumber =
-            await DashboardDomainService.countBy({
-              query: {
-                _id: id.toString(),
-              },
-              props: databaseProps,
-            });
-
-          if (domainCount.toNumber() === 0) {
-            return Response.sendErrorResponse(
-              req,
-              res,
-              new BadDataException(
-                "The domain does not exist or user does not have access to it.",
-              ),
-            );
-          }
-
-          const domain: DashboardDomain | null =
-            await DashboardDomainService.findOneBy({
-              query: {
-                _id: id.toString(),
-              },
-              select: {
-                _id: true,
-                fullDomain: true,
-              },
-              props: {
-                isRoot: true,
-              },
-            });
-
-          if (!domain) {
-            return Response.sendErrorResponse(
-              req,
-              res,
-              new BadDataException("Invalid token."),
-            );
-          }
-
-          if (!domain.fullDomain) {
-            return Response.sendErrorResponse(
-              req,
-              res,
-              new BadDataException("Invalid domain."),
-            );
-          }
-
-          const isValid: boolean = await DashboardDomainService.isCnameValid(
-            domain.fullDomain!,
-          );
-
-          if (!isValid) {
-            return Response.sendErrorResponse(
-              req,
-              res,
-              new BadDataException(
-                "CNAME is not verified. Please make sure you have the correct record and please verify CNAME again. If you are sure that the record is correct, please wait for some time for the DNS to propagate.",
-              ),
-            );
-          }
-
-          return Response.sendEmptySuccessResponse(req, res);
-        } catch (e) {
-          next(e);
-        }
+    /*
+     * Check now (verify-cname) and the Status column's certificates: the
+     * same routes as a status page's custom domains, registered once for
+     * both (CustomDomainRoutes). Check now used to answer an empty body here,
+     * and the certificate waited for an "Order Free SSL" button or the next
+     * order sweep.
+     */
+    CustomDomainRoutes.add({
+      router: this.router,
+      crudApiPath: new this.entityType().getCrudApiPath()?.toString() || "",
+      service: DashboardDomainService,
+      getCnameRecord: (): string => {
+        return DashboardCNameRecord;
       },
-    );
+      parentColumn: "dashboardId",
+    });
 
-    // Provision SSL API
+    /*
+     * Order SSL. The dashboard no longer has a button for this: a domain's
+     * certificate is ordered as soon as its CNAME is verified, by Check now
+     * or by the sweeps. It stays for API callers, and orders the way
+     * everything else does, through orderCertIfMissing - a domain that has
+     * its certificate already, or has one being ordered right now, is not
+     * ordered twice - and never for a domain on an uploaded certificate.
+     *
+     * It shares Check now's window: one order on demand per domain per 15
+     * minutes, whichever of the two placed it. An order that fails leaves the
+     * domain unordered, so without it a script calling this in a loop placed
+     * an order on every call, against the account the whole installation
+     * shares.
+     */
     this.router.get(
       `${new this.entityType().getCrudApiPath()?.toString()}/order-ssl/:id`,
       UserMiddleware.getUserMiddleware,
@@ -172,6 +112,9 @@ export default class DashboardDomainAPI extends BaseAPI<
                 cnameVerificationToken: true,
                 isCnameVerified: true,
                 isSslProvisioned: true,
+                isCustomCertificate: true,
+                // Whose on-demand orders the order counts against.
+                projectId: true,
               },
               props: {
                 isRoot: true,
@@ -212,6 +155,17 @@ export default class DashboardDomainAPI extends BaseAPI<
             );
           }
 
+          // The sweeps never order for one either: it serves the upload.
+          if (domain.isCustomCertificate) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException(
+                "This domain uses a certificate you uploaded, so there is no free SSL certificate to order for it.",
+              ),
+            );
+          }
+
           if (!domain.fullDomain) {
             return Response.sendErrorResponse(
               req,
@@ -225,7 +179,23 @@ export default class DashboardDomainAPI extends BaseAPI<
             getLogAttributesFromRequest(req as OneUptimeRequest),
           );
 
-          await DashboardDomainService.orderCert(domain);
+          try {
+            await CertificateOrder.orderOnDemand({
+              domain: domain.fullDomain,
+              order: () => {
+                return DashboardDomainService.orderCertIfMissing(domain, {
+                  onDemand: true,
+                });
+              },
+            });
+          } catch (err) {
+            // Too soon, or nothing ordered: the order's own failures go on.
+            if (err instanceof TooManyRequestsException) {
+              return Response.sendErrorResponse(req, res, err);
+            }
+
+            throw err;
+          }
 
           logger.debug(
             "SSL Provisioned for domain - " + domain.fullDomain,