@oneuptime/common 7.0.2990 → 7.0.3010

package/Server/Services/StatusPageDomainService.ts

@@ -17,6 +17,7 @@ import AcmeCertificate from "Common/Models/DatabaseModels/AcmeCertificate";
 import Domain from "Common/Models/DatabaseModels/Domain";
 import StatusPageDomain from "Common/Models/DatabaseModels/StatusPageDomain";
 import AcmeCertificateService from "./AcmeCertificateService";
+import Telemetry, { Span } from "../Utils/Telemetry";
 
 export class Service extends DatabaseService<StatusPageDomain> {
   public constructor() {
@@ -86,49 +87,79 @@ export class Service extends DatabaseService<StatusPageDomain> {
   }
 
   public async orderCert(statusPageDomain: StatusPageDomain): Promise<void> {
-    if (!statusPageDomain.fullDomain) {
-      const fetchedStatusPageDomain: StatusPageDomain | null =
-        await this.findOneBy({
-          query: {
-            _id: statusPageDomain.id!.toString(),
-          },
-          select: {
-            _id: true,
-            fullDomain: true,
-          },
-          props: {
-            isRoot: true,
-          },
-        });
-
-      if (!fetchedStatusPageDomain) {
-        throw new BadDataException("Domain not found");
-      }
+    return Telemetry.startActiveSpan<Promise<void>>({
+      name: "StatusPageDomainService.orderCert",
+      options: {
+        attributes: {
+          fullDomain: statusPageDomain.fullDomain,
+          _id: statusPageDomain.id?.toString(),
+        },
+      },
+      fn: async (span: Span): Promise<void> => {
+        try {
+          if (!statusPageDomain.fullDomain) {
+            const fetchedStatusPageDomain: StatusPageDomain | null =
+              await this.findOneBy({
+                query: {
+                  _id: statusPageDomain.id!.toString(),
+                },
+                select: {
+                  _id: true,
+                  fullDomain: true,
+                },
+                props: {
+                  isRoot: true,
+                },
+              });
+
+            if (!fetchedStatusPageDomain) {
+              throw new BadDataException("Domain not found");
+            }
+
+            statusPageDomain = fetchedStatusPageDomain;
+          }
+
+          if (!statusPageDomain.fullDomain) {
+            throw new BadDataException(
+              "Unable to order certificate because domain is null",
+            );
+          }
+
+          logger.debug(
+            "Ordering SSL for domain: " + statusPageDomain.fullDomain,
+          );
 
-      statusPageDomain = fetchedStatusPageDomain;
-    }
+          await GreenlockUtil.orderCert({
+            domain: statusPageDomain.fullDomain as string,
+            validateCname: async (fullDomain: string) => {
+              return await this.isCnameValid(fullDomain);
+            },
+          });
 
-    if (!statusPageDomain.fullDomain) {
-      throw new BadDataException(
-        "Unable to order certificate because domain is null",
-      );
-    }
+          logger.debug(
+            "SSL ordered for domain: " + statusPageDomain.fullDomain,
+          );
 
-    await GreenlockUtil.orderCert({
-      domain: statusPageDomain.fullDomain as string,
-      validateCname: async (fullDomain: string) => {
-        return await this.isCnameValid(fullDomain);
-      },
-    });
+          // update the order.
+          await this.updateOneById({
+            id: statusPageDomain.id!,
+            data: {
+              isSslOrdered: true,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+
+          Telemetry.endSpan(span);
+        } catch (err) {
+          Telemetry.recordExceptionMarkSpanAsErrorAndEndSpan({
+            span,
+            exception: err,
+          });
 
-    // update the order.
-    await this.updateOneById({
-      id: statusPageDomain.id!,
-      data: {
-        isSslOrdered: true,
-      },
-      props: {
-        isRoot: true,
+          throw err;
+        }
       },
     });
   }
@@ -215,6 +246,8 @@ export class Service extends DatabaseService<StatusPageDomain> {
     try {
       // get the token from the domain.
 
+      logger.debug("Checking for CNAME " + fullDomain);
+
       const statusPageDomain: StatusPageDomain | null = await this.findOneBy({
         query: {
           fullDomain: fullDomain,
@@ -234,6 +267,8 @@ export class Service extends DatabaseService<StatusPageDomain> {
 
       const token: string = statusPageDomain.cnameVerificationToken!;
 
+      logger.debug("Checking for CNAME " + fullDomain + " with token " + token);
+
       const result: HTTPErrorResponse | HTTPResponse<JSONObject> =
         await API.get(
           URL.fromString(
@@ -244,6 +279,9 @@ export class Service extends DatabaseService<StatusPageDomain> {
           ),
         );
 
+      logger.debug("CNAME verification result");
+      logger.debug(result);
+
       if (result.isSuccess()) {
         await this.updateCnameStatusForStatusPageDomain({
           domain: fullDomain,
@@ -265,6 +303,9 @@ export class Service extends DatabaseService<StatusPageDomain> {
           ),
         );
 
+      logger.debug("CNAME verification result for https");
+      logger.debug(resultHttps);
+
       if (resultHttps.isSuccess()) {
         await this.updateCnameStatusForStatusPageDomain({
           domain: fullDomain,
@@ -370,28 +411,46 @@ export class Service extends DatabaseService<StatusPageDomain> {
   }
 
   public async orderSSLForDomainsWhichAreNotOrderedYet(): Promise<void> {
-    const domains: Array<StatusPageDomain> = await this.findBy({
-      query: {
-        isSslOrdered: false,
-      },
-      select: {
-        _id: true,
-        fullDomain: true,
-      },
-      limit: LIMIT_MAX,
-      skip: 0,
-      props: {
-        isRoot: true,
+    return Telemetry.startActiveSpan<Promise<void>>({
+      name: "StatusPageDomainService.orderSSLForDomainsWhichAreNotOrderedYet",
+      options: { attributes: {} },
+      fn: async (span: Span): Promise<void> => {
+        try {
+          const domains: Array<StatusPageDomain> = await this.findBy({
+            query: {
+              isSslOrdered: false,
+            },
+            select: {
+              _id: true,
+              fullDomain: true,
+            },
+            limit: LIMIT_MAX,
+            skip: 0,
+            props: {
+              isRoot: true,
+            },
+          });
+
+          for (const domain of domains) {
+            try {
+              logger.debug("Ordering SSL for domain: " + domain.fullDomain);
+              await this.orderCert(domain);
+            } catch (e) {
+              logger.error(e);
+            }
+          }
+
+          Telemetry.endSpan(span);
+        } catch (err) {
+          Telemetry.recordExceptionMarkSpanAsErrorAndEndSpan({
+            span,
+            exception: err,
+          });
+
+          throw err;
+        }
       },
     });
-
-    for (const domain of domains) {
-      try {
-        await this.orderCert(domain);
-      } catch (e) {
-        logger.error(e);
-      }
-    }
   }
 
   public async verifyCnameWhoseCnameisNotVerified(): Promise<void> {

package/Server/Services/TelemetryExceptionService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import Model from "Common/Models/DatabaseModels/TelemetryException";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+
+export default new Service();

package/Server/Types/Database/Permissions/Index.ts

@@ -1,3 +1,4 @@
+import QueryDeepPartialEntity from "../../../../Types/Database/PartialEntity";
 import Query from "../Query";
 import Select from "../Select";
 import CreatePermission from "./CreatePermission";
@@ -6,7 +7,6 @@ import ReadPermission, { CheckReadPermissionType } from "./ReadPermission";
 import UpdatePermission from "./UpdatePermission";
 import BaseModel from "Common/Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
 import DatabaseCommonInteractionProps from "Common/Types/BaseDatabase/DatabaseCommonInteractionProps";
-import { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
 
 export default class ModelPermission {
   public static async checkDeletePermissionByModel<

package/Server/Types/Database/UpdateByID.ts

@@ -1,7 +1,7 @@
 import BaseModel from "Common/Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
 import DatabaseCommonInteractionProps from "Common/Types/BaseDatabase/DatabaseCommonInteractionProps";
 import ObjectID from "Common/Types/ObjectID";
-import { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
+import QueryDeepPartialEntity from "../../../Types/Database/PartialEntity";
 
 export default interface UpdateBy<TBaseModel extends BaseModel> {
   id: ObjectID;