@oneuptime/common 11.3.20 → 11.3.21

package/Server/API/EnterpriseLicenseAPI.ts

@@ -1,9 +1,18 @@
 import EnterpriseLicense from "../../Models/DatabaseModels/EnterpriseLicense";
+import EnterpriseLicenseInstance from "../../Models/DatabaseModels/EnterpriseLicenseInstance";
 import BadDataException from "../../Types/Exception/BadDataException";
 import { JSONObject } from "../../Types/JSON";
+import PartialEntity from "../../Types/Database/PartialEntity";
+import EnterpriseLicenseInstanceSummary from "../../Types/EnterpriseLicense/EnterpriseLicenseInstanceSummary";
+import EnterpriseLicenseUsageUtil from "../../Utils/EnterpriseLicense/EnterpriseLicenseUsage";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import ObjectID from "../../Types/ObjectID";
+import PositiveNumber from "../../Types/PositiveNumber";
+import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import EnterpriseLicenseService, {
   Service as EnterpriseLicenseServiceType,
 } from "../Services/EnterpriseLicenseService";
+import EnterpriseLicenseInstanceService from "../Services/EnterpriseLicenseInstanceService";
 import UserMiddleware from "../Middleware/UserAuthorization";
 import JSONWebToken from "../Utils/JsonWebToken";
 import OneUptimeDate from "../../Types/Date";
@@ -16,6 +25,23 @@ import {
 import BaseAPI from "./BaseAPI";
 // import { Host } from "../EnvironmentConfig";
 
+export interface LicenseInstanceUpsert {
+  licenseId: ObjectID;
+  instanceId: string;
+  host: string | undefined;
+  // Usage fields are only set on report-user-count, not on validate.
+  userCount?: number | undefined;
+  userEmailHashes?: Array<string> | undefined;
+  lastReportedAt?: Date | undefined;
+}
+
+/*
+ * Bounds how many instance rows one license key can register. Real customers
+ * run a handful of instances; this stops a leaked key from being used to
+ * fill the table with junk rows.
+ */
+const MAX_INSTANCES_PER_LICENSE: number = 100;
+
 export default class EnterpriseLicenseAPI extends BaseAPI<
   EnterpriseLicense,
   EnterpriseLicenseServiceType
@@ -50,6 +76,7 @@ export default class EnterpriseLicenseAPI extends BaseAPI<
                 licenseKey: licenseKey,
               },
               select: {
+                _id: true,
                 companyName: true,
                 expiresAt: true,
                 licenseKey: true,
@@ -80,6 +107,27 @@ export default class EnterpriseLicenseAPI extends BaseAPI<
             throw new BadDataException("License key has expired");
           }
 
+          /*
+           * The validating instance sends its instanceId and host so it
+           * shows up in the instance list right away (usage is reported
+           * later by the daily job on the instance).
+           */
+          const instanceId: string = this.parseShortText(
+            req.body["instanceId"],
+          );
+          const instanceHost: string = this.parseShortText(req.body["host"]);
+
+          if (instanceId) {
+            await this.upsertLicenseInstance({
+              licenseId: license.id!,
+              instanceId: instanceId,
+              host: instanceHost || undefined,
+            });
+          }
+
+          const instances: Array<EnterpriseLicenseInstance> =
+            await this.findLicenseInstances(license.id!);
+
           const payload: JSONObject = {
             companyName: license.companyName || "",
             expiresAt: license.expiresAt.toISOString(),
@@ -105,6 +153,7 @@ export default class EnterpriseLicenseAPI extends BaseAPI<
             userCountUpdatedAt: license.userCountUpdatedAt
               ? license.userCountUpdatedAt.toISOString()
               : null,
+            instances: this.getInstanceSummaries(instances),
             token,
           });
         } catch (err) {
@@ -158,23 +207,67 @@ export default class EnterpriseLicenseAPI extends BaseAPI<
 
           const reportedAt: Date = OneUptimeDate.getCurrentDate();
 
-          await EnterpriseLicenseService.updateOneById({
-            id: license.id!,
-            data: {
-              currentUserCount: userCount,
-              userCountUpdatedAt: reportedAt,
-            },
-            props: {
-              isRoot: true,
-              ignoreHooks: true,
-            },
-          });
+          const instanceId: string = this.parseShortText(
+            req.body["instanceId"],
+          );
+          const instanceHost: string = this.parseShortText(req.body["host"]);
+          const userEmailHashes: Array<string> =
+            EnterpriseLicenseUsageUtil.sanitizeUserEmailHashes(
+              req.body["userEmailHashes"],
+            );
+
+          if (instanceId) {
+            /*
+             * Multi-instance report: track usage per instance and count
+             * users uniquely across all instances of this license.
+             */
+            await this.upsertLicenseInstance({
+              licenseId: license.id!,
+              instanceId: instanceId,
+              host: instanceHost || undefined,
+              userCount: userCount,
+              userEmailHashes: userEmailHashes,
+              lastReportedAt: reportedAt,
+            });
+          }
+
+          const instances: Array<EnterpriseLicenseInstance> =
+            await this.findLicenseInstances(license.id!);
+
+          let currentUserCount: number = userCount;
+
+          if (instances.length > 0) {
+            currentUserCount = EnterpriseLicenseUsageUtil.getUniqueUserCount(
+              instances,
+              reportedAt,
+            );
+          }
+
+          /*
+           * Legacy reports (no instanceId) only drive the license-wide count
+           * while no instance has registered — otherwise they would stomp
+           * the deduplicated multi-instance count.
+           */
+          if (instanceId || instances.length === 0) {
+            await EnterpriseLicenseService.updateOneById({
+              id: license.id!,
+              data: {
+                currentUserCount: currentUserCount,
+                userCountUpdatedAt: reportedAt,
+              },
+              props: {
+                isRoot: true,
+                ignoreHooks: true,
+              },
+            });
+          }
 
           return Response.sendJsonObjectResponse(req, res, {
-            currentUserCount: userCount,
+            currentUserCount: currentUserCount,
             userCountUpdatedAt: reportedAt.toISOString(),
             userLimit:
               typeof license.userLimit === "number" ? license.userLimit : null,
+            instances: this.getInstanceSummaries(instances),
           });
         } catch (err) {
           next(err);
@@ -182,4 +275,178 @@ export default class EnterpriseLicenseAPI extends BaseAPI<
       },
     );
   }
+
+  private parseShortText(value: unknown): string {
+    if (typeof value !== "string") {
+      return "";
+    }
+
+    return value.trim().substring(0, 100);
+  }
+
+  private async findLicenseInstances(
+    licenseId: ObjectID,
+  ): Promise<Array<EnterpriseLicenseInstance>> {
+    return EnterpriseLicenseInstanceService.findBy({
+      query: {
+        enterpriseLicenseId: licenseId,
+      },
+      select: {
+        _id: true,
+        instanceId: true,
+        host: true,
+        userCount: true,
+        userEmailHashes: true,
+        lastReportedAt: true,
+      },
+      sort: {
+        createdAt: SortOrder.Ascending,
+      },
+      skip: 0,
+      limit: LIMIT_MAX,
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
+  private getInstanceSummaries(
+    instances: Array<EnterpriseLicenseInstance>,
+  ): Array<EnterpriseLicenseInstanceSummary> {
+    return instances.map(
+      (
+        instance: EnterpriseLicenseInstance,
+      ): EnterpriseLicenseInstanceSummary => {
+        return {
+          instanceId: instance.instanceId || "",
+          host: instance.host || null,
+          userCount:
+            typeof instance.userCount === "number" ? instance.userCount : null,
+          lastReportedAt: instance.lastReportedAt
+            ? instance.lastReportedAt.toISOString()
+            : null,
+        };
+      },
+    );
+  }
+
+  private async upsertLicenseInstance(
+    data: LicenseInstanceUpsert,
+  ): Promise<void> {
+    const updated: boolean = await this.updateLicenseInstanceIfExists(data);
+
+    if (updated) {
+      return;
+    }
+
+    const instanceCount: PositiveNumber =
+      await EnterpriseLicenseInstanceService.countBy({
+        query: {
+          enterpriseLicenseId: data.licenseId,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (instanceCount.toNumber() >= MAX_INSTANCES_PER_LICENSE) {
+      throw new BadDataException(
+        "Too many instances are registered for this license. Please contact support@oneuptime.com.",
+      );
+    }
+
+    const newInstance: EnterpriseLicenseInstance =
+      new EnterpriseLicenseInstance();
+    newInstance.enterpriseLicenseId = data.licenseId;
+    newInstance.instanceId = data.instanceId;
+
+    if (data.host !== undefined) {
+      newInstance.host = data.host;
+    }
+
+    if (data.userCount !== undefined) {
+      newInstance.userCount = data.userCount;
+    }
+
+    if (data.userEmailHashes !== undefined) {
+      newInstance.userEmailHashes = data.userEmailHashes;
+    }
+
+    if (data.lastReportedAt !== undefined) {
+      newInstance.lastReportedAt = data.lastReportedAt;
+    }
+
+    try {
+      await EnterpriseLicenseInstanceService.create({
+        data: newInstance,
+        props: {
+          isRoot: true,
+        },
+      });
+    } catch (err) {
+      /*
+       * A concurrent request created the row between our check and this
+       * insert — the unique index on (enterpriseLicenseId, instanceId)
+       * rejected the duplicate. Apply the report as an update instead.
+       */
+      const retried: boolean = await this.updateLicenseInstanceIfExists(data);
+
+      if (!retried) {
+        throw err;
+      }
+    }
+  }
+
+  private async updateLicenseInstanceIfExists(
+    data: LicenseInstanceUpsert,
+  ): Promise<boolean> {
+    const existingInstance: EnterpriseLicenseInstance | null =
+      await EnterpriseLicenseInstanceService.findOneBy({
+        query: {
+          enterpriseLicenseId: data.licenseId,
+          instanceId: data.instanceId,
+        },
+        select: {
+          _id: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!existingInstance) {
+      return false;
+    }
+
+    const updateData: PartialEntity<EnterpriseLicenseInstance> = {};
+
+    if (data.host !== undefined) {
+      updateData.host = data.host;
+    }
+
+    if (data.userCount !== undefined) {
+      updateData.userCount = data.userCount;
+    }
+
+    if (data.userEmailHashes !== undefined) {
+      updateData.userEmailHashes = data.userEmailHashes;
+    }
+
+    if (data.lastReportedAt !== undefined) {
+      updateData.lastReportedAt = data.lastReportedAt;
+    }
+
+    if (Object.keys(updateData).length > 0) {
+      await EnterpriseLicenseInstanceService.updateOneById({
+        id: existingInstance.id!,
+        data: updateData,
+        props: {
+          isRoot: true,
+          ignoreHooks: true,
+        },
+      });
+    }
+
+    return true;
+  }
 }

package/Server/API/GlobalConfigAPI.ts

@@ -5,6 +5,7 @@ import {
   ExpressRequest,
   ExpressResponse,
   NextFunction,
+  OneUptimeRequest,
 } from "../Utils/Express";
 import Response from "../Utils/Response";
 import BaseAPI from "./BaseAPI";
@@ -16,7 +17,8 @@ import API from "../../Utils/API";
 import HTTPErrorResponse from "../../Types/API/HTTPErrorResponse";
 import HTTPResponse from "../../Types/API/HTTPResponse";
 import PartialEntity from "../../Types/Database/PartialEntity";
-import { EnterpriseLicenseValidationUrl } from "../EnvironmentConfig";
+import { EnterpriseLicenseValidationUrl, Host } from "../EnvironmentConfig";
+import EnterpriseLicenseInstanceSummary from "../../Types/EnterpriseLicense/EnterpriseLicenseInstanceSummary";
 import UserMiddleware from "../Middleware/UserAuthorization";
 
 export default class GlobalConfigAPI extends BaseAPI<
@@ -54,6 +56,7 @@ export default class GlobalConfigAPI extends BaseAPI<
 
     this.router.get(
       `${new this.entityType().getCrudApiPath()?.toString()}/license`,
+      UserMiddleware.getUserMiddleware,
       async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
         try {
           const config: GlobalConfig | null =
@@ -67,19 +70,42 @@ export default class GlobalConfigAPI extends BaseAPI<
                 enterpriseLicenseUserLimit: true,
                 enterpriseLicenseCurrentUserCount: true,
                 enterpriseLicenseUserCountUpdatedAt: true,
+                enterpriseLicenseInstances: true,
+                instanceId: true,
               },
               props: {
                 isRoot: true,
               },
             });
 
+          /*
+           * This route also serves the login page (before sign-in), so it
+           * cannot require authentication outright. Anonymous callers only
+           * get enough to render the edition pill — the license key, token
+           * and instance topology require a signed-in user.
+           */
+          const isAuthenticatedUser: boolean = Boolean(
+            (req as OneUptimeRequest).userAuthorization?.userId,
+          );
+
+          const licenseValid: boolean = Boolean(
+            config?.enterpriseLicenseToken &&
+              config?.enterpriseLicenseExpiresAt &&
+              config.enterpriseLicenseExpiresAt.getTime() > Date.now(),
+          );
+
           const responseBody: JSONObject = {
             companyName: config?.enterpriseCompanyName || null,
             expiresAt: config?.enterpriseLicenseExpiresAt
               ? config.enterpriseLicenseExpiresAt.toISOString()
               : null,
-            licenseKey: config?.enterpriseLicenseKey || null,
-            token: config?.enterpriseLicenseToken || null,
+            licenseKey: isAuthenticatedUser
+              ? config?.enterpriseLicenseKey || null
+              : null,
+            token: isAuthenticatedUser
+              ? config?.enterpriseLicenseToken || null
+              : null,
+            licenseValid: licenseValid,
             userLimit:
               typeof config?.enterpriseLicenseUserLimit === "number"
                 ? config.enterpriseLicenseUserLimit
@@ -91,6 +117,15 @@ export default class GlobalConfigAPI extends BaseAPI<
             userCountUpdatedAt: config?.enterpriseLicenseUserCountUpdatedAt
               ? config.enterpriseLicenseUserCountUpdatedAt.toISOString()
               : null,
+            instances:
+              isAuthenticatedUser &&
+              Array.isArray(config?.enterpriseLicenseInstances)
+                ? config.enterpriseLicenseInstances
+                : [],
+            instanceId:
+              isAuthenticatedUser && config?.instanceId
+                ? config.instanceId.toString()
+                : null,
           };
 
           return Response.sendJsonObjectResponse(req, res, responseBody);
@@ -112,12 +147,38 @@ export default class GlobalConfigAPI extends BaseAPI<
             throw new BadDataException("License key is required");
           }
 
+          const globalConfigId: ObjectID = ObjectID.getZeroObjectID();
+
+          const existingConfig: GlobalConfig | null =
+            await GlobalConfigService.findOneById({
+              id: globalConfigId,
+              select: {
+                _id: true,
+                instanceId: true,
+              },
+              props: {
+                isRoot: true,
+                ignoreHooks: true,
+              },
+            });
+
+          /*
+           * Send this instance's id and host along with the key so the
+           * license server registers this instance against the license and
+           * it shows up in the instance list on all instances that share
+           * the license.
+           */
+          const instanceId: ObjectID =
+            existingConfig?.instanceId || ObjectID.generate();
+
           const validationResponse:
             | HTTPResponse<JSONObject>
             | HTTPErrorResponse = await API.post<JSONObject>({
             url: EnterpriseLicenseValidationUrl,
             data: {
               licenseKey,
+              instanceId: instanceId.toString(),
+              host: Host,
             },
           });
 
@@ -178,6 +239,13 @@ export default class GlobalConfigAPI extends BaseAPI<
             }
           }
 
+          const instances: Array<EnterpriseLicenseInstanceSummary> =
+            Array.isArray(payload["instances"])
+              ? (payload[
+                  "instances"
+                ] as Array<EnterpriseLicenseInstanceSummary>)
+              : [];
+
           const updatePayload: PartialEntity<GlobalConfig> = {
             enterpriseCompanyName: companyNameRaw || null,
             enterpriseLicenseKey: licenseKeyRaw || null,
@@ -186,21 +254,13 @@ export default class GlobalConfigAPI extends BaseAPI<
             enterpriseLicenseUserLimit: userLimit,
             enterpriseLicenseCurrentUserCount: currentUserCount,
             enterpriseLicenseUserCountUpdatedAt: userCountUpdatedAt,
+            enterpriseLicenseInstances: instances,
           };
 
-          const globalConfigId: ObjectID = ObjectID.getZeroObjectID();
-
-          const existingConfig: GlobalConfig | null =
-            await GlobalConfigService.findOneById({
-              id: globalConfigId,
-              select: {
-                _id: true,
-              },
-              props: {
-                isRoot: true,
-                ignoreHooks: true,
-              },
-            });
+          if (!existingConfig?.instanceId) {
+            // Installs that predate instance ids: persist the one we generated.
+            updatePayload.instanceId = instanceId;
+          }
 
           if (existingConfig) {
             await GlobalConfigService.updateOneById({
@@ -244,6 +304,9 @@ export default class GlobalConfigAPI extends BaseAPI<
                 userCountUpdatedAt;
             }
 
+            newConfig.enterpriseLicenseInstances = instances;
+            newConfig.instanceId = instanceId;
+
             await GlobalConfigService.create({
               data: newConfig,
               props: {
@@ -263,6 +326,8 @@ export default class GlobalConfigAPI extends BaseAPI<
             userCountUpdatedAt: userCountUpdatedAt
               ? userCountUpdatedAt.toISOString()
               : null,
+            instances: instances,
+            instanceId: instanceId.toString(),
           });
         } catch (err) {
           next(err);