@oneuptime/common 7.0.3840 → 7.0.3864

package/Server/Utils/Greenlock/Greenlock.ts

@@ -17,369 +17,317 @@ import AcmeCertificate from "Common/Models/DatabaseModels/AcmeCertificate";
 import AcmeChallenge from "Common/Models/DatabaseModels/AcmeChallenge";
 import acme from "acme-client";
 import { Challenge } from "acme-client/types/rfc8555";
-import Telemetry, { Span } from "../Telemetry";
+import CaptureSpan from "../Telemetry/CaptureSpan";
 
 export default class GreenlockUtil {
+  @CaptureSpan()
   public static async renewAllCertsWhichAreExpiringSoon(data: {
     validateCname: (domain: string) => Promise<boolean>;
     notifyDomainRemoved: (domain: string) => Promise<void>;
   }): Promise<void> {
-    return await Telemetry.startActiveSpan<Promise<void>>({
-      name: "GreenlockUtil.renewAllCertsWhichAreExpiringSoon",
-      fn: async (span: Span): Promise<void> => {
-        try {
-          logger.debug("Renewing all certificates");
+    try {
+      logger.debug("Renewing all certificates");
+
+      // get all certificates which are expiring soon
+
+      const certificates: AcmeCertificate[] =
+        await AcmeCertificateService.findBy({
+          query: {
+            expiresAt: QueryHelper.lessThanEqualTo(
+              OneUptimeDate.addRemoveDays(
+                OneUptimeDate.getCurrentDate(),
+                40, // 40 days before expiry
+              ),
+            ),
+          },
+          limit: LIMIT_MAX,
+          skip: 0,
+          select: {
+            domain: true,
+          },
+          sort: {
+            expiresAt: SortOrder.Ascending,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+      logger.debug(
+        `Found ${certificates.length} certificates which are expiring soon`,
+      );
+
+      // order certificate for each domain
+
+      for (const certificate of certificates) {
+        if (!certificate.domain) {
+          continue;
+        }
 
-          // get all certificates which are expiring soon
+        logger.debug(`Renewing certificate for domain: ${certificate.domain}`);
 
-          const certificates: AcmeCertificate[] =
-            await AcmeCertificateService.findBy({
-              query: {
-                expiresAt: QueryHelper.lessThanEqualTo(
-                  OneUptimeDate.addRemoveDays(
-                    OneUptimeDate.getCurrentDate(),
-                    40, // 40 days before expiry
-                  ),
-                ),
-              },
-              limit: LIMIT_MAX,
-              skip: 0,
-              select: {
-                domain: true,
-              },
-              sort: {
-                expiresAt: SortOrder.Ascending,
-              },
-              props: {
-                isRoot: true,
-              },
-            });
-
-          logger.debug(
-            `Found ${certificates.length} certificates which are expiring soon`,
+        try {
+          //validate cname
+          const isValidCname: boolean = await data.validateCname(
+            certificate.domain,
           );
 
-          // order certificate for each domain
+          if (!isValidCname) {
+            logger.debug(
+              `CNAME is not valid for domain: ${certificate.domain}`,
+            );
 
-          for (const certificate of certificates) {
-            if (!certificate.domain) {
-              continue;
-            }
+            // if cname is not valid then remove the domain
+            await GreenlockUtil.removeDomain(certificate.domain);
+            await data.notifyDomainRemoved(certificate.domain);
 
-            logger.debug(
-              `Renewing certificate for domain: ${certificate.domain}`,
+            logger.error(
+              `Cname is not valid for domain: ${certificate.domain}`,
             );
+          } else {
+            logger.debug(`CNAME is valid for domain: ${certificate.domain}`);
 
-            try {
-              //validate cname
-              const isValidCname: boolean = await data.validateCname(
-                certificate.domain,
-              );
-
-              if (!isValidCname) {
-                logger.debug(
-                  `CNAME is not valid for domain: ${certificate.domain}`,
-                );
-
-                // if cname is not valid then remove the domain
-                await GreenlockUtil.removeDomain(certificate.domain);
-                await data.notifyDomainRemoved(certificate.domain);
-
-                logger.error(
-                  `Cname is not valid for domain: ${certificate.domain}`,
-                );
-              } else {
-                logger.debug(
-                  `CNAME is valid for domain: ${certificate.domain}`,
-                );
-
-                await GreenlockUtil.orderCert({
-                  domain: certificate.domain,
-                  validateCname: data.validateCname,
-                });
-
-                logger.debug(
-                  `Certificate renewed for domain: ${certificate.domain}`,
-                );
-              }
-            } catch (e) {
-              logger.error(
-                `Error renewing certificate for domain: ${certificate.domain}`,
-              );
-              logger.error(e);
-            }
-          }
+            await GreenlockUtil.orderCert({
+              domain: certificate.domain,
+              validateCname: data.validateCname,
+            });
 
-          Telemetry.endSpan(span);
+            logger.debug(
+              `Certificate renewed for domain: ${certificate.domain}`,
+            );
+          }
         } catch (e) {
-          logger.error("Error renewing all certificates");
+          logger.error(
+            `Error renewing certificate for domain: ${certificate.domain}`,
+          );
           logger.error(e);
-
-          // record exception
-          Telemetry.recordExceptionMarkSpanAsErrorAndEndSpan({
-            span,
-            exception: e,
-          });
-
-          throw e;
         }
-      },
-    });
+      }
+    } catch (e) {
+      logger.error("Error renewing all certificates");
+      logger.error(e);
+
+      throw e;
+    }
   }
 
+  @CaptureSpan()
   public static async removeDomain(domain: string): Promise<void> {
-    return await Telemetry.startActiveSpan<Promise<void>>({
-      name: "GreenlockUtil.orderCert",
-      options: {
-        attributes: {
+    try {
+      // remove certificate for this domain.
+      await AcmeCertificateService.deleteBy({
+        query: {
           domain: domain,
         },
-      },
-      fn: async (span: Span): Promise<void> => {
-        try {
-          // remove certificate for this domain.
-          await AcmeCertificateService.deleteBy({
-            query: {
-              domain: domain,
-            },
-            limit: 1,
-            skip: 0,
-            props: {
-              isRoot: true,
-            },
-          });
-
-          Telemetry.endSpan(span);
-        } catch (err) {
-          logger.error(`Error removing domain: ${domain}`);
-
-          Telemetry.recordExceptionMarkSpanAsErrorAndEndSpan({
-            span,
-            exception: err,
-          });
-
-          throw err;
-        }
-      },
-    });
+        limit: 1,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+    } catch (err) {
+      logger.error(`Error removing domain: ${domain}`);
+      throw err;
+    }
   }
 
+  @CaptureSpan()
   public static async orderCert(data: {
     domain: string;
     validateCname: (domain: string) => Promise<boolean>;
   }): Promise<void> {
-    return await Telemetry.startActiveSpan<Promise<void>>({
-      name: "GreenlockUtil.orderCert",
-      options: {
-        attributes: {
-          domain: data.domain,
-        },
-      },
-      fn: async (span: Span): Promise<void> => {
-        try {
-          logger.debug(
-            `GreenlockUtil - Ordering certificate for domain: ${data.domain}`,
-          );
+    try {
+      logger.debug(
+        `GreenlockUtil - Ordering certificate for domain: ${data.domain}`,
+      );
 
-          let { domain } = data;
+      let { domain } = data;
 
-          domain = domain.trim().toLowerCase();
+      domain = domain.trim().toLowerCase();
 
-          const acmeAccountKeyInBase64: string = LetsEncryptAccountKey;
+      const acmeAccountKeyInBase64: string = LetsEncryptAccountKey;
 
-          if (!acmeAccountKeyInBase64) {
-            throw new ServerException(
-              "No lets encrypt account key found in environment variables. Please add one.",
-            );
-          }
+      if (!acmeAccountKeyInBase64) {
+        throw new ServerException(
+          "No lets encrypt account key found in environment variables. Please add one.",
+        );
+      }
 
-          let acmeAccountKey: string = Buffer.from(
-            acmeAccountKeyInBase64,
-            "base64",
-          ).toString();
+      let acmeAccountKey: string = Buffer.from(
+        acmeAccountKeyInBase64,
+        "base64",
+      ).toString();
 
-          acmeAccountKey = Text.replaceAll(acmeAccountKey, "\\n", "\n");
+      acmeAccountKey = Text.replaceAll(acmeAccountKey, "\\n", "\n");
 
-          //validate cname
+      //validate cname
 
-          logger.debug(`Validating cname for domain: ${domain}`);
+      logger.debug(`Validating cname for domain: ${domain}`);
 
-          const isValidCname: boolean = await data.validateCname(domain);
+      const isValidCname: boolean = await data.validateCname(domain);
 
-          if (!isValidCname) {
-            logger.debug(`CNAME is not valid for domain: ${domain}`);
-            logger.debug(`Removing domain: ${domain}`);
+      if (!isValidCname) {
+        logger.debug(`CNAME is not valid for domain: ${domain}`);
+        logger.debug(`Removing domain: ${domain}`);
 
-            await GreenlockUtil.removeDomain(domain);
-            logger.error(`Cname is not valid for domain: ${domain}`);
-            throw new BadDataException(
-              "Cname is not valid for domain " + domain,
-            );
-          }
+        await GreenlockUtil.removeDomain(domain);
+        logger.error(`Cname is not valid for domain: ${domain}`);
+        throw new BadDataException("Cname is not valid for domain " + domain);
+      }
 
-          logger.debug(`Cname is valid for domain: ${domain}`);
+      logger.debug(`Cname is valid for domain: ${domain}`);
 
-          const client: acme.Client = new acme.Client({
-            directoryUrl: acme.directory.letsencrypt.production,
-            accountKey: acmeAccountKey,
-          });
+      const client: acme.Client = new acme.Client({
+        directoryUrl: acme.directory.letsencrypt.production,
+        accountKey: acmeAccountKey,
+      });
 
-          const [certificateKey, certificateRequest] =
-            await acme.crypto.createCsr({
-              commonName: domain,
-            });
+      const [certificateKey, certificateRequest] = await acme.crypto.createCsr({
+        commonName: domain,
+      });
 
-          logger.debug(`Ordering certificate for domain: ${domain}`);
-
-          const certificate: string = await client.auto({
-            csr: certificateRequest,
-            email: LetsEncryptNotificationEmail.toString(),
-            termsOfServiceAgreed: true,
-            challengePriority: ["http-01"], // only http-01 challenge is supported by oneuptime
-            challengeCreateFn: async (
-              authz: acme.Authorization,
-              challenge: Challenge,
-              keyAuthorization: string,
-            ) => {
-              // Satisfy challenge here
-              /* http-01 */
-              if (challenge.type === "http-01") {
-                logger.debug(
-                  `Creating challenge for domain: ${authz.identifier.value}`,
-                );
-
-                const acmeChallenge: AcmeChallenge = new AcmeChallenge();
-                acmeChallenge.challenge = keyAuthorization;
-                acmeChallenge.token = challenge.token;
-                acmeChallenge.domain = authz.identifier.value;
-
-                await AcmeChallengeService.create({
-                  data: acmeChallenge,
-                  props: {
-                    isRoot: true,
-                  },
-                });
-
-                logger.debug(
-                  `Challenge created for domain: ${authz.identifier.value}`,
-                );
-              }
-            },
-            challengeRemoveFn: async (
-              authz: acme.Authorization,
-              challenge: Challenge,
-            ) => {
-              // Clean up challenge here
-
-              logger.debug(
-                `Removing challenge for domain: ${authz.identifier.value}`,
-              );
-
-              if (challenge.type === "http-01") {
-                await AcmeChallengeService.deleteBy({
-                  query: {
-                    domain: authz.identifier.value,
-                  },
-                  limit: 1,
-                  skip: 0,
-                  props: {
-                    isRoot: true,
-                  },
-                });
-              }
-
-              logger.debug(
-                `Challenge removed for domain: ${authz.identifier.value}`,
-              );
-            },
-          });
-
-          logger.debug(`Certificate ordered for domain: ${domain}`);
-
-          // get expires at date from certificate
-          const cert: acme.CertificateInfo =
-            acme.crypto.readCertificateInfo(certificate);
-          const issuedAt: Date = cert.notBefore;
-          const expiresAt: Date = cert.notAfter;
-
-          logger.debug(`Certificate expires at: ${expiresAt}`);
-          logger.debug(`Certificate issued at: ${issuedAt}`);
-
-          // check if the certificate is already in the database.
-          const existingCertificate: AcmeCertificate | null =
-            await AcmeCertificateService.findOneBy({
-              query: {
-                domain: domain,
-              },
-              select: {
-                _id: true,
-              },
+      logger.debug(`Ordering certificate for domain: ${domain}`);
+
+      const certificate: string = await client.auto({
+        csr: certificateRequest,
+        email: LetsEncryptNotificationEmail.toString(),
+        termsOfServiceAgreed: true,
+        challengePriority: ["http-01"], // only http-01 challenge is supported by oneuptime
+        challengeCreateFn: async (
+          authz: acme.Authorization,
+          challenge: Challenge,
+          keyAuthorization: string,
+        ) => {
+          // Satisfy challenge here
+          /* http-01 */
+          if (challenge.type === "http-01") {
+            logger.debug(
+              `Creating challenge for domain: ${authz.identifier.value}`,
+            );
+
+            const acmeChallenge: AcmeChallenge = new AcmeChallenge();
+            acmeChallenge.challenge = keyAuthorization;
+            acmeChallenge.token = challenge.token;
+            acmeChallenge.domain = authz.identifier.value;
+
+            await AcmeChallengeService.create({
+              data: acmeChallenge,
               props: {
                 isRoot: true,
               },
             });
 
-          if (existingCertificate) {
-            logger.debug(`Updating certificate for domain: ${domain}`);
+            logger.debug(
+              `Challenge created for domain: ${authz.identifier.value}`,
+            );
+          }
+        },
+        challengeRemoveFn: async (
+          authz: acme.Authorization,
+          challenge: Challenge,
+        ) => {
+          // Clean up challenge here
 
-            // update the certificate
-            await AcmeCertificateService.updateBy({
+          logger.debug(
+            `Removing challenge for domain: ${authz.identifier.value}`,
+          );
+
+          if (challenge.type === "http-01") {
+            await AcmeChallengeService.deleteBy({
               query: {
-                domain: domain,
+                domain: authz.identifier.value,
               },
               limit: 1,
               skip: 0,
-              data: {
-                certificate: certificate.toString(),
-                certificateKey: certificateKey.toString(),
-                issuedAt: issuedAt,
-                expiresAt: expiresAt,
-              },
-              props: {
-                isRoot: true,
-              },
-            });
-
-            logger.debug(`Certificate updated for domain: ${domain}`);
-          } else {
-            logger.debug(`Creating certificate for domain: ${domain}`);
-            // create the certificate
-            const acmeCertificate: AcmeCertificate = new AcmeCertificate();
-
-            acmeCertificate.domain = domain;
-            acmeCertificate.certificate = certificate.toString();
-            acmeCertificate.certificateKey = certificateKey.toString();
-            acmeCertificate.issuedAt = issuedAt;
-            acmeCertificate.expiresAt = expiresAt;
-
-            await AcmeCertificateService.create({
-              data: acmeCertificate,
               props: {
                 isRoot: true,
               },
             });
-
-            logger.debug(`Certificate created for domain: ${domain}`);
           }
 
-          Telemetry.endSpan(span);
-        } catch (e) {
-          logger.error(`Error ordering certificate for domain: ${data.domain}`);
-
-          Telemetry.recordExceptionMarkSpanAsErrorAndEndSpan({
-            span,
-            exception: e,
-          });
-
-          if (e instanceof Exception) {
-            throw e;
-          }
-
-          throw new ServerException(
-            `Unable to order certificate for ${data.domain}. Please contact support at support@oneuptime.com for more information.`,
+          logger.debug(
+            `Challenge removed for domain: ${authz.identifier.value}`,
           );
-        }
-      },
-    });
+        },
+      });
+
+      logger.debug(`Certificate ordered for domain: ${domain}`);
+
+      // get expires at date from certificate
+      const cert: acme.CertificateInfo =
+        acme.crypto.readCertificateInfo(certificate);
+      const issuedAt: Date = cert.notBefore;
+      const expiresAt: Date = cert.notAfter;
+
+      logger.debug(`Certificate expires at: ${expiresAt}`);
+      logger.debug(`Certificate issued at: ${issuedAt}`);
+
+      // check if the certificate is already in the database.
+      const existingCertificate: AcmeCertificate | null =
+        await AcmeCertificateService.findOneBy({
+          query: {
+            domain: domain,
+          },
+          select: {
+            _id: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+      if (existingCertificate) {
+        logger.debug(`Updating certificate for domain: ${domain}`);
+
+        // update the certificate
+        await AcmeCertificateService.updateBy({
+          query: {
+            domain: domain,
+          },
+          limit: 1,
+          skip: 0,
+          data: {
+            certificate: certificate.toString(),
+            certificateKey: certificateKey.toString(),
+            issuedAt: issuedAt,
+            expiresAt: expiresAt,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+        logger.debug(`Certificate updated for domain: ${domain}`);
+      } else {
+        logger.debug(`Creating certificate for domain: ${domain}`);
+        // create the certificate
+        const acmeCertificate: AcmeCertificate = new AcmeCertificate();
+
+        acmeCertificate.domain = domain;
+        acmeCertificate.certificate = certificate.toString();
+        acmeCertificate.certificateKey = certificateKey.toString();
+        acmeCertificate.issuedAt = issuedAt;
+        acmeCertificate.expiresAt = expiresAt;
+
+        await AcmeCertificateService.create({
+          data: acmeCertificate,
+          props: {
+            isRoot: true,
+          },
+        });
+
+        logger.debug(`Certificate created for domain: ${domain}`);
+      }
+    } catch (e) {
+      logger.error(`Error ordering certificate for domain: ${data.domain}`);
+
+      if (e instanceof Exception) {
+        throw e;
+      }
+
+      throw new ServerException(
+        `Unable to order certificate for ${data.domain}. Please contact support at support@oneuptime.com for more information.`,
+      );
+    }
   }
 }

package/Server/Utils/JsonWebToken.ts

@@ -10,8 +10,10 @@ import Timezone from "Common/Types/Timezone";
 import StatusPagePrivateUser from "Common/Models/DatabaseModels/StatusPagePrivateUser";
 import User from "Common/Models/DatabaseModels/User";
 import jwt from "jsonwebtoken";
+import CaptureSpan from "./Telemetry/CaptureSpan";
 
 class JSONWebToken {
+  @CaptureSpan()
   public static signUserLoginToken(data: {
     tokenData: {
       userId: ObjectID;
@@ -30,6 +32,7 @@ class JSONWebToken {
     });
   }
 
+  @CaptureSpan()
   public static sign(props: {
     data: JSONWebTokenData | User | StatusPagePrivateUser | string | JSONObject;
     expiresInSeconds: number;
@@ -69,6 +72,7 @@ class JSONWebToken {
     return JSONWebToken.signJsonPayload(jsonObj, expiresInSeconds);
   }
 
+  @CaptureSpan()
   public static signJsonPayload(
     payload: JSONObject,
     expiresInSeconds: number,
@@ -78,6 +82,7 @@ class JSONWebToken {
     });
   }
 
+  @CaptureSpan()
   public static decodeJsonPayload(token: string): JSONObject {
     const decodedToken: string = JSON.stringify(
       jwt.verify(token, EncryptionSecret.toString()) as string,
@@ -87,6 +92,7 @@ class JSONWebToken {
     return decoded;
   }
 
+  @CaptureSpan()
   public static decode(token: string): JSONWebTokenData {
     try {
       const decoded: JSONObject = JSONWebToken.decodeJsonPayload(token);