@oneuptime/common 10.7.2 → 10.8.0

package/Server/Services/RumApplicationService.ts

@@ -0,0 +1,301 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/RumApplication";
+import Label from "../../Models/DatabaseModels/Label";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import ObjectID from "../../Types/ObjectID";
+import QueryHelper from "../Types/Database/QueryHelper";
+import OneUptimeDate from "../../Types/Date";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import GlobalCache from "../Infrastructure/GlobalCache";
+import logger, { LogAttributes } from "../Utils/Logger";
+import crypto from "crypto";
+import { OnCreate } from "../Types/Database/Hooks";
+import RumApplicationLabelRuleEngineService from "./RumApplicationLabelRuleEngineService";
+import RumApplicationOwnerRuleEngineService from "./RumApplicationOwnerRuleEngineService";
+
+const LAST_SEEN_CACHE_NAMESPACE: string = "rum-application-last-seen";
+const LAST_SEEN_THROTTLE_SECONDS: number = 60;
+
+const LABELS_APPLIED_CACHE_NAMESPACE: string = "rum-application-labels-applied";
+const LABELS_APPLIED_CACHE_TTL_SECONDS: number = 60;
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  @CaptureSpan()
+  protected override async onCreateSuccess(
+    _onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    if (createdItem.projectId && createdItem.id) {
+      Promise.resolve()
+        .then(async () => {
+          await RumApplicationLabelRuleEngineService.applyRulesToRumApplication(
+            createdItem,
+          );
+        })
+        .then(async () => {
+          await RumApplicationOwnerRuleEngineService.applyRulesToRumApplication(
+            createdItem,
+          );
+        })
+        .catch((error: Error) => {
+          logger.error(
+            `Error applying RUM application rules in RumApplicationService.onCreateSuccess: ${error}`,
+            {
+              projectId: createdItem.projectId?.toString(),
+              rumApplicationId: createdItem.id?.toString(),
+            } as LogAttributes,
+          );
+        });
+    }
+    return createdItem;
+  }
+
+  @CaptureSpan()
+  public async findOrCreateByAppIdentifier(data: {
+    projectId: ObjectID;
+    appIdentifier: string;
+  }): Promise<Model> {
+    const existingApp: Model | null = await this.findOneBy({
+      query: {
+        projectId: data.projectId,
+        appIdentifier: QueryHelper.findWithSameText(data.appIdentifier),
+      },
+      select: {
+        _id: true,
+        projectId: true,
+        appIdentifier: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (existingApp) {
+      return existingApp;
+    }
+
+    try {
+      const newApp: Model = new Model();
+      newApp.projectId = data.projectId;
+      newApp.name = data.appIdentifier;
+      newApp.appIdentifier = data.appIdentifier;
+      newApp.otelCollectorStatus = "connected";
+      newApp.lastSeenAt = OneUptimeDate.getCurrentDate();
+
+      const createdApp: Model = await this.create({
+        data: newApp,
+        props: {
+          isRoot: true,
+        },
+      });
+
+      return createdApp;
+    } catch {
+      const reFetchedApp: Model | null = await this.findOneBy({
+        query: {
+          projectId: data.projectId,
+          appIdentifier: QueryHelper.findWithSameText(data.appIdentifier),
+        },
+        select: {
+          _id: true,
+          projectId: true,
+          appIdentifier: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (reFetchedApp) {
+        return reFetchedApp;
+      }
+
+      throw new Error(
+        "Failed to create or find RUM application: " + data.appIdentifier,
+      );
+    }
+  }
+
+  @CaptureSpan()
+  public async updateLastSeen(
+    rumApplicationId: ObjectID,
+    extra?: {
+      agentVersion?: string | undefined;
+      clientType?: string | undefined;
+      sdkLanguage?: string | undefined;
+    },
+  ): Promise<void> {
+    const cacheKey: string = rumApplicationId.toString();
+    const extrasFingerprint: string = crypto
+      .createHash("sha1")
+      .update(
+        JSON.stringify({
+          agentVersion: extra?.agentVersion ?? null,
+          clientType: extra?.clientType ?? null,
+          sdkLanguage: extra?.sdkLanguage ?? null,
+        }),
+      )
+      .digest("hex");
+
+    const cached: string | null = await GlobalCache.getString(
+      LAST_SEEN_CACHE_NAMESPACE,
+      cacheKey,
+    );
+
+    if (cached === extrasFingerprint) {
+      return; // same data was written recently
+    }
+
+    await GlobalCache.setString(
+      LAST_SEEN_CACHE_NAMESPACE,
+      cacheKey,
+      extrasFingerprint,
+      { expiresInSeconds: LAST_SEEN_THROTTLE_SECONDS },
+    );
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const data: any = {
+      lastSeenAt: OneUptimeDate.getCurrentDate(),
+      otelCollectorStatus: "connected",
+    };
+
+    if (extra?.agentVersion) {
+      data.agentVersion = extra.agentVersion;
+    }
+    if (extra?.clientType) {
+      data.clientType = extra.clientType;
+    }
+    if (extra?.sdkLanguage) {
+      data.sdkLanguage = extra.sdkLanguage;
+    }
+
+    await this.updateOneById({
+      id: rumApplicationId,
+      data: data,
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
+  @CaptureSpan()
+  public async attachLabels(data: {
+    rumApplicationId: ObjectID;
+    labelIds: Array<ObjectID>;
+  }): Promise<void> {
+    if (!data.labelIds || data.labelIds.length === 0) {
+      return;
+    }
+
+    const cacheKey: string = data.rumApplicationId.toString();
+    const fingerprint: string = fingerprintLabelIds(data.labelIds);
+    const cached: string | null = await GlobalCache.getString(
+      LABELS_APPLIED_CACHE_NAMESPACE,
+      cacheKey,
+    );
+    if (cached === fingerprint) {
+      return;
+    }
+
+    try {
+      const appIdStr: string = data.rumApplicationId.toString();
+      const existingLabels: Array<Label> = await this.getRepository()
+        .createQueryBuilder()
+        .relation(Model, "labels")
+        .of(appIdStr)
+        .loadMany();
+
+      const existingIds: Set<string> = new Set();
+      for (const lbl of existingLabels) {
+        const idStr: string | undefined = lbl._id?.toString();
+        if (idStr) {
+          existingIds.add(idStr);
+        }
+      }
+
+      const toAddIds: Array<string> = [];
+      const seen: Set<string> = new Set();
+      for (const id of data.labelIds) {
+        const idStr: string = id.toString();
+        if (existingIds.has(idStr) || seen.has(idStr)) {
+          continue;
+        }
+        seen.add(idStr);
+        toAddIds.push(idStr);
+      }
+
+      if (toAddIds.length > 0) {
+        await this.getRepository()
+          .createQueryBuilder()
+          .relation(Model, "labels")
+          .of(appIdStr)
+          .add(toAddIds);
+      }
+
+      await GlobalCache.setString(
+        LABELS_APPLIED_CACHE_NAMESPACE,
+        cacheKey,
+        fingerprint,
+        { expiresInSeconds: LABELS_APPLIED_CACHE_TTL_SECONDS },
+      );
+    } catch (err) {
+      logger.warn(
+        `RumApplicationService.attachLabels failed for application ${data.rumApplicationId.toString()}: ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      );
+    }
+  }
+
+  @CaptureSpan()
+  public async markDisconnectedApplications(): Promise<void> {
+    const fiveMinutesAgo: Date = OneUptimeDate.addRemoveMinutes(
+      OneUptimeDate.getCurrentDate(),
+      -5,
+    );
+
+    const connectedApps: Array<Model> = await this.findBy({
+      query: {
+        otelCollectorStatus: "connected",
+        lastSeenAt: QueryHelper.lessThan(fiveMinutesAgo),
+      },
+      select: {
+        _id: true,
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    for (const rumApplication of connectedApps) {
+      if (rumApplication._id) {
+        await this.updateOneById({
+          id: new ObjectID(rumApplication._id.toString()),
+          data: {
+            otelCollectorStatus: "disconnected",
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+      }
+    }
+  }
+}
+
+function fingerprintLabelIds(labelIds: Array<ObjectID>): string {
+  const sorted: Array<string> = labelIds
+    .map((id: ObjectID) => {
+      return id.toString();
+    })
+    .sort();
+  return crypto.createHash("sha1").update(sorted.join(",")).digest("hex");
+}
+
+export default new Service();

package/Server/Services/ServerlessFunctionInstanceService.ts

@@ -0,0 +1,61 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/ServerlessFunctionInstance";
+import ObjectID from "../../Types/ObjectID";
+import OneUptimeDate from "../../Types/Date";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger from "../Utils/Logger";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  /**
+   * Upsert a serverless function instance (faas.instance) from ingest.
+   * Refreshes lastSeenAt if the instance already exists.
+   */
+  @CaptureSpan()
+  public async recordInstance(data: {
+    projectId: ObjectID;
+    serverlessFunctionId: ObjectID;
+    instanceName: string;
+  }): Promise<void> {
+    try {
+      const existing: Model | null = await this.findOneBy({
+        query: {
+          projectId: data.projectId,
+          serverlessFunctionId: data.serverlessFunctionId,
+          instanceName: data.instanceName,
+        },
+        select: { _id: true },
+        props: { isRoot: true },
+      });
+
+      if (existing && existing._id) {
+        await this.updateOneById({
+          id: new ObjectID(existing._id.toString()),
+          data: { lastSeenAt: OneUptimeDate.getCurrentDate() },
+          props: { isRoot: true },
+        });
+        return;
+      }
+
+      const item: Model = new Model();
+      item.projectId = data.projectId;
+      item.serverlessFunctionId = data.serverlessFunctionId;
+      item.instanceName = data.instanceName;
+      item.lastSeenAt = OneUptimeDate.getCurrentDate();
+      await this.create({ data: item, props: { isRoot: true } });
+    } catch (err) {
+      // Inventory is best-effort — a unique-violation race or transient error
+      // must never fail ingest.
+      logger.warn(
+        `ServerlessFunctionInstanceService.recordInstance failed: ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      );
+    }
+  }
+}
+
+export default new Service();

package/Server/Services/ServerlessFunctionLabelRuleEngineService.ts

@@ -0,0 +1,182 @@
+import Label from "../../Models/DatabaseModels/Label";
+import ServerlessFunction from "../../Models/DatabaseModels/ServerlessFunction";
+import ServerlessFunctionLabelRule from "../../Models/DatabaseModels/ServerlessFunctionLabelRule";
+import ServerlessFunctionLabelRuleService from "./ServerlessFunctionLabelRuleService";
+import ServerlessFunctionService from "./ServerlessFunctionService";
+import ObjectID from "../../Types/ObjectID";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger, { LogAttributes } from "../Utils/Logger";
+
+class ServerlessFunctionLabelRuleEngineServiceClass {
+  /**
+   * Evaluates ServerlessFunctionLabelRule rows for the given function and
+   * attaches matched labels. The union is deduped against labels already on
+   * the function before insert to avoid PK conflicts on the join table.
+   */
+  @CaptureSpan()
+  public async applyRulesToServerlessFunction(
+    serverlessFunction: ServerlessFunction,
+  ): Promise<void> {
+    if (!serverlessFunction.id || !serverlessFunction.projectId) {
+      return;
+    }
+
+    try {
+      const rules: Array<ServerlessFunctionLabelRule> =
+        await ServerlessFunctionLabelRuleService.findBy({
+          query: {
+            projectId: serverlessFunction.projectId,
+            isEnabled: true,
+          },
+          props: { isRoot: true },
+          select: {
+            _id: true,
+            name: true,
+            matchLabels: { _id: true },
+            nameRegexPattern: true,
+            descriptionRegexPattern: true,
+            labelsToAdd: { _id: true },
+          },
+          limit: 100,
+          skip: 0,
+        });
+
+      if (rules.length === 0) {
+        return;
+      }
+
+      const fnWithDetails: ServerlessFunction | null =
+        await ServerlessFunctionService.findOneById({
+          id: serverlessFunction.id,
+          select: {
+            name: true,
+            description: true,
+            labels: { _id: true },
+          },
+          props: { isRoot: true },
+        });
+
+      if (!fnWithDetails) {
+        return;
+      }
+
+      const labelIdsToAdd: Set<string> = new Set();
+
+      for (const rule of rules) {
+        if (!this.doesMatchRule(fnWithDetails, rule)) {
+          continue;
+        }
+        for (const label of rule.labelsToAdd || []) {
+          if (label.id) {
+            labelIdsToAdd.add(label.id.toString());
+          }
+        }
+      }
+
+      if (labelIdsToAdd.size === 0) {
+        return;
+      }
+
+      const existingLabelIds: Set<string> = new Set(
+        (fnWithDetails.labels || [])
+          .map((l: Label) => {
+            return l.id?.toString() || "";
+          })
+          .filter((id: string) => {
+            return id !== "";
+          }),
+      );
+
+      const newLabelIds: Array<string> = Array.from(labelIdsToAdd).filter(
+        (id: string) => {
+          return !existingLabelIds.has(id);
+        },
+      );
+      if (newLabelIds.length === 0) {
+        return;
+      }
+
+      await ServerlessFunctionService.getRepository()
+        .createQueryBuilder()
+        .relation(ServerlessFunction, "labels")
+        .of(serverlessFunction.id.toString())
+        .add(newLabelIds);
+
+      const mergedLabelIds: Set<string> = new Set([
+        ...existingLabelIds,
+        ...newLabelIds,
+      ]);
+      serverlessFunction.labels = Array.from(mergedLabelIds).map(
+        (id: string) => {
+          const label: Label = new Label();
+          label.id = new ObjectID(id);
+          return label;
+        },
+      );
+    } catch (error) {
+      logger.error(`Error applying serverless function label rules: ${error}`, {
+        projectId: serverlessFunction.projectId?.toString(),
+        serverlessFunctionId: serverlessFunction.id?.toString(),
+      } as LogAttributes);
+    }
+  }
+
+  private doesMatchRule(
+    serverlessFunction: ServerlessFunction,
+    rule: ServerlessFunctionLabelRule,
+  ): boolean {
+    if (rule.matchLabels && rule.matchLabels.length > 0) {
+      if (!serverlessFunction.labels || serverlessFunction.labels.length === 0) {
+        return false;
+      }
+      const ruleLabelIds: Array<string> = rule.matchLabels.map((l: Label) => {
+        return l.id?.toString() || "";
+      });
+      const labelIds: Array<string> = serverlessFunction.labels.map(
+        (l: Label) => {
+          return l.id?.toString() || "";
+        },
+      );
+      if (
+        !ruleLabelIds.some((id: string) => {
+          return labelIds.includes(id);
+        })
+      ) {
+        return false;
+      }
+    }
+
+    if (
+      rule.nameRegexPattern &&
+      (!serverlessFunction.name ||
+        !this.testRegex(rule.nameRegexPattern, serverlessFunction.name))
+    ) {
+      return false;
+    }
+
+    if (
+      rule.descriptionRegexPattern &&
+      (!serverlessFunction.description ||
+        !this.testRegex(
+          rule.descriptionRegexPattern,
+          serverlessFunction.description,
+        ))
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+
+  private testRegex(pattern: string, value: string): boolean {
+    try {
+      const regex: RegExp = new RegExp(pattern, "i");
+      return regex.test(value);
+    } catch {
+      logger.warn(`Invalid regex in serverless function label rule: ${pattern}`);
+      return false;
+    }
+  }
+}
+
+export default new ServerlessFunctionLabelRuleEngineServiceClass();

package/Server/Services/ServerlessFunctionLabelRuleService.ts

@@ -0,0 +1,14 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/ServerlessFunctionLabelRule";
+import { IsBillingEnabled } from "../EnvironmentConfig";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 3 * 365);
+    }
+  }
+}
+
+export default new Service();