@oneuptime/common 10.7.1 → 10.8.0

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -367,6 +367,17 @@ import { MigrationName1780387560604 } from "./1780387560604-MigrationName";
 import { MigrationName1780388219225 } from "./1780388219225-MigrationName";
 import { AddMetricAndTraceSavedView1780645560183 } from "./1780645560183-AddMetricAndTraceSavedView";
 import { AddKubernetesLatestMemoryPercent1780651429467 } from "./1780651429467-AddKubernetesLatestMemoryPercent";
+import { AddResumeStateToWorkflowLog1780931746908 } from "./1780931746908-AddResumeStateToWorkflowLog";
+import { AddTelemetryResourceMetadataColumns1780931863719 } from "./1780931863719-AddTelemetryResourceMetadataColumns";
+import { AddServerlessFunctionTables1780933132562 } from "./1780933132562-AddServerlessFunctionTables";
+import { AddCloudResourceTables1780935387827 } from "./1780935387827-AddCloudResourceTables";
+import { AddRumApplicationTables1780936579718 } from "./1780936579718-AddRumApplicationTables";
+import { AddServerlessFunctionRuleTables1780938407319 } from "./1780938407319-AddServerlessFunctionRuleTables";
+import { AddCloudResourceRuleTables1780940721814 } from "./1780940721814-AddCloudResourceRuleTables";
+import { AddRumApplicationRuleTables1780940998002 } from "./1780940998002-AddRumApplicationRuleTables";
+import { AddTelemetryResourceInventoryTables1780941762204 } from "./1780941762204-AddTelemetryResourceInventoryTables";
+import { AddRumApplicationSdkLanguage1780985763463 } from "./1780985763463-AddRumApplicationSdkLanguage";
+import { RecastCloudResourcesByEnvironment1780987192743 } from "./1780987192743-RecastCloudResourcesByEnvironment";
 
 export default [
   InitialMigration,
@@ -738,4 +749,15 @@ export default [
   MigrationName1780388219225,
   AddMetricAndTraceSavedView1780645560183,
   AddKubernetesLatestMemoryPercent1780651429467,
+  AddResumeStateToWorkflowLog1780931746908,
+  AddTelemetryResourceMetadataColumns1780931863719,
+  AddServerlessFunctionTables1780933132562,
+  AddCloudResourceTables1780935387827,
+  AddRumApplicationTables1780936579718,
+  AddServerlessFunctionRuleTables1780938407319,
+  AddCloudResourceRuleTables1780940721814,
+  AddRumApplicationRuleTables1780940998002,
+  AddTelemetryResourceInventoryTables1780941762204,
+  AddRumApplicationSdkLanguage1780985763463,
+  RecastCloudResourcesByEnvironment1780987192743,
 ];

package/Server/Infrastructure/Queue.ts

@@ -192,6 +192,13 @@ export default class Queue {
     options?: {
       scheduleAt?: string | undefined;
       repeatableKey?: string | undefined;
+      /**
+       * One-off delay in milliseconds before the job becomes eligible to run.
+       * Mutually exclusive with `scheduleAt` (a repeatable cron pattern); if
+       * both are set, `scheduleAt` wins. Used to park a delayed job (e.g. the
+       * Sleep component's durable resume).
+       */
+      delayInMs?: number | undefined;
     },
   ): Promise<Job> {
     const sanitizedJobId: string = this.sanitizeJobId(jobId.toString());
@@ -200,6 +207,10 @@ export default class Queue {
       jobId: sanitizedJobId,
     };
 
+    if (options && options.delayInMs && options.delayInMs > 0) {
+      optionsObject.delay = options.delayInMs;
+    }
+
     const queue: BullQueue = this.getQueue(queueName);
 
     if (options && options.scheduleAt) {

package/Server/Services/CloudResourceInstanceService.ts

@@ -0,0 +1,76 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/CloudResourceInstance";
+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 cloud-resource instance / task (service.instance.id) from ingest.
+   * Refreshes lastSeenAt (and cpu/mem when provided) if it already exists.
+   */
+  @CaptureSpan()
+  public async recordInstance(data: {
+    projectId: ObjectID;
+    cloudResourceId: ObjectID;
+    instanceName: string;
+    cpuPercent?: number | undefined;
+    memoryBytes?: number | undefined;
+  }): Promise<void> {
+    try {
+      const existing: Model | null = await this.findOneBy({
+        query: {
+          projectId: data.projectId,
+          cloudResourceId: data.cloudResourceId,
+          instanceName: data.instanceName,
+        },
+        select: { _id: true },
+        props: { isRoot: true },
+      });
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const fields: any = { lastSeenAt: OneUptimeDate.getCurrentDate() };
+      if (data.cpuPercent !== undefined) {
+        fields.latestCpuPercent = data.cpuPercent;
+      }
+      if (data.memoryBytes !== undefined) {
+        fields.latestMemoryBytes = data.memoryBytes;
+      }
+
+      if (existing && existing._id) {
+        await this.updateOneById({
+          id: new ObjectID(existing._id.toString()),
+          data: fields,
+          props: { isRoot: true },
+        });
+        return;
+      }
+
+      const item: Model = new Model();
+      item.projectId = data.projectId;
+      item.cloudResourceId = data.cloudResourceId;
+      item.instanceName = data.instanceName;
+      item.lastSeenAt = OneUptimeDate.getCurrentDate();
+      if (data.cpuPercent !== undefined) {
+        item.latestCpuPercent = data.cpuPercent;
+      }
+      if (data.memoryBytes !== undefined) {
+        item.latestMemoryBytes = data.memoryBytes;
+      }
+      await this.create({ data: item, props: { isRoot: true } });
+    } catch (err) {
+      logger.warn(
+        `CloudResourceInstanceService.recordInstance failed: ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      );
+    }
+  }
+}
+
+export default new Service();

package/Server/Services/CloudResourceLabelRuleEngineService.ts

@@ -0,0 +1,175 @@
+import Label from "../../Models/DatabaseModels/Label";
+import CloudResource from "../../Models/DatabaseModels/CloudResource";
+import CloudResourceLabelRule from "../../Models/DatabaseModels/CloudResourceLabelRule";
+import CloudResourceLabelRuleService from "./CloudResourceLabelRuleService";
+import CloudResourceService from "./CloudResourceService";
+import ObjectID from "../../Types/ObjectID";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger, { LogAttributes } from "../Utils/Logger";
+
+class CloudResourceLabelRuleEngineServiceClass {
+  /**
+   * Evaluates CloudResourceLabelRule rows for the given resource and attaches
+   * matched labels. The union is deduped against labels already on the
+   * resource before insert to avoid PK conflicts on the join table.
+   */
+  @CaptureSpan()
+  public async applyRulesToCloudResource(
+    cloudResource: CloudResource,
+  ): Promise<void> {
+    if (!cloudResource.id || !cloudResource.projectId) {
+      return;
+    }
+
+    try {
+      const rules: Array<CloudResourceLabelRule> =
+        await CloudResourceLabelRuleService.findBy({
+          query: {
+            projectId: cloudResource.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 resourceWithDetails: CloudResource | null =
+        await CloudResourceService.findOneById({
+          id: cloudResource.id,
+          select: {
+            name: true,
+            description: true,
+            labels: { _id: true },
+          },
+          props: { isRoot: true },
+        });
+
+      if (!resourceWithDetails) {
+        return;
+      }
+
+      const labelIdsToAdd: Set<string> = new Set();
+
+      for (const rule of rules) {
+        if (!this.doesMatchRule(resourceWithDetails, 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(
+        (resourceWithDetails.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 CloudResourceService.getRepository()
+        .createQueryBuilder()
+        .relation(CloudResource, "labels")
+        .of(cloudResource.id.toString())
+        .add(newLabelIds);
+
+      const mergedLabelIds: Set<string> = new Set([
+        ...existingLabelIds,
+        ...newLabelIds,
+      ]);
+      cloudResource.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 cloud resource label rules: ${error}`, {
+        projectId: cloudResource.projectId?.toString(),
+        cloudResourceId: cloudResource.id?.toString(),
+      } as LogAttributes);
+    }
+  }
+
+  private doesMatchRule(
+    cloudResource: CloudResource,
+    rule: CloudResourceLabelRule,
+  ): boolean {
+    if (rule.matchLabels && rule.matchLabels.length > 0) {
+      if (!cloudResource.labels || cloudResource.labels.length === 0) {
+        return false;
+      }
+      const ruleLabelIds: Array<string> = rule.matchLabels.map((l: Label) => {
+        return l.id?.toString() || "";
+      });
+      const labelIds: Array<string> = cloudResource.labels.map((l: Label) => {
+        return l.id?.toString() || "";
+      });
+      if (
+        !ruleLabelIds.some((id: string) => {
+          return labelIds.includes(id);
+        })
+      ) {
+        return false;
+      }
+    }
+
+    if (
+      rule.nameRegexPattern &&
+      (!cloudResource.name ||
+        !this.testRegex(rule.nameRegexPattern, cloudResource.name))
+    ) {
+      return false;
+    }
+
+    if (
+      rule.descriptionRegexPattern &&
+      (!cloudResource.description ||
+        !this.testRegex(rule.descriptionRegexPattern, cloudResource.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 cloud resource label rule: ${pattern}`);
+      return false;
+    }
+  }
+}
+
+export default new CloudResourceLabelRuleEngineServiceClass();

package/Server/Services/CloudResourceLabelRuleService.ts

@@ -0,0 +1,14 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/CloudResourceLabelRule";
+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();

package/Server/Services/CloudResourceOwnerRuleEngineService.ts

@@ -0,0 +1,192 @@
+import Label from "../../Models/DatabaseModels/Label";
+import CloudResource from "../../Models/DatabaseModels/CloudResource";
+import CloudResourceOwnerRule from "../../Models/DatabaseModels/CloudResourceOwnerRule";
+import CloudResourceOwnerUser from "../../Models/DatabaseModels/CloudResourceOwnerUser";
+import CloudResourceOwnerTeam from "../../Models/DatabaseModels/CloudResourceOwnerTeam";
+import CloudResourceOwnerRuleService from "./CloudResourceOwnerRuleService";
+import CloudResourceOwnerUserService from "./CloudResourceOwnerUserService";
+import CloudResourceOwnerTeamService from "./CloudResourceOwnerTeamService";
+import CloudResourceService from "./CloudResourceService";
+import ObjectID from "../../Types/ObjectID";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger, { LogAttributes } from "../Utils/Logger";
+
+class CloudResourceOwnerRuleEngineServiceClass {
+  /**
+   * Evaluates CloudResourceOwnerRule rows for the given resource and adds
+   * matched owner users / teams. Rules with notifyOwners set notify the added
+   * owners; rules with notifyOwners off add silently.
+   */
+  @CaptureSpan()
+  public async applyRulesToCloudResource(
+    cloudResource: CloudResource,
+  ): Promise<void> {
+    if (!cloudResource.id || !cloudResource.projectId) {
+      return;
+    }
+
+    try {
+      const rules: Array<CloudResourceOwnerRule> =
+        await CloudResourceOwnerRuleService.findBy({
+          query: {
+            projectId: cloudResource.projectId,
+            isEnabled: true,
+          },
+          props: { isRoot: true },
+          select: {
+            _id: true,
+            name: true,
+            notifyOwners: true,
+            matchLabels: { _id: true },
+            nameRegexPattern: true,
+            descriptionRegexPattern: true,
+            ownerUsers: { _id: true },
+            ownerTeams: { _id: true },
+          },
+          limit: 100,
+          skip: 0,
+        });
+
+      if (rules.length === 0) {
+        return;
+      }
+
+      const resourceWithDetails: CloudResource | null =
+        await CloudResourceService.findOneById({
+          id: cloudResource.id,
+          select: {
+            name: true,
+            description: true,
+            labels: { _id: true },
+          },
+          props: { isRoot: true },
+        });
+
+      if (!resourceWithDetails) {
+        return;
+      }
+
+      const usersByNotify: Map<boolean, Set<string>> = new Map([
+        [true, new Set()],
+        [false, new Set()],
+      ]);
+      const teamsByNotify: Map<boolean, Set<string>> = new Map([
+        [true, new Set()],
+        [false, new Set()],
+      ]);
+
+      let anyMatched: boolean = false;
+
+      for (const rule of rules) {
+        if (!this.doesMatchRule(resourceWithDetails, rule)) {
+          continue;
+        }
+        const notify: boolean = rule.notifyOwners !== false;
+        for (const user of rule.ownerUsers || []) {
+          if (user.id) {
+            usersByNotify.get(notify)!.add(user.id.toString());
+            anyMatched = true;
+          }
+        }
+        for (const team of rule.ownerTeams || []) {
+          if (team.id) {
+            teamsByNotify.get(notify)!.add(team.id.toString());
+            anyMatched = true;
+          }
+        }
+      }
+
+      if (!anyMatched) {
+        return;
+      }
+
+      for (const notify of [true, false]) {
+        const userIds: Set<string> = usersByNotify.get(notify)!;
+        const teamIds: Set<string> = teamsByNotify.get(notify)!;
+
+        for (const userId of userIds) {
+          const owner: CloudResourceOwnerUser = new CloudResourceOwnerUser();
+          owner.cloudResourceId = cloudResource.id;
+          owner.projectId = cloudResource.projectId;
+          owner.userId = new ObjectID(userId);
+          owner.isOwnerNotified = !notify;
+          await CloudResourceOwnerUserService.create({
+            data: owner,
+            props: { isRoot: true },
+          });
+        }
+
+        for (const teamId of teamIds) {
+          const owner: CloudResourceOwnerTeam = new CloudResourceOwnerTeam();
+          owner.cloudResourceId = cloudResource.id;
+          owner.projectId = cloudResource.projectId;
+          owner.teamId = new ObjectID(teamId);
+          owner.isOwnerNotified = !notify;
+          await CloudResourceOwnerTeamService.create({
+            data: owner,
+            props: { isRoot: true },
+          });
+        }
+      }
+    } catch (error) {
+      logger.error(`Error applying cloud resource owner rules: ${error}`, {
+        projectId: cloudResource.projectId?.toString(),
+        cloudResourceId: cloudResource.id?.toString(),
+      } as LogAttributes);
+    }
+  }
+
+  private doesMatchRule(
+    cloudResource: CloudResource,
+    rule: CloudResourceOwnerRule,
+  ): boolean {
+    if (rule.matchLabels && rule.matchLabels.length > 0) {
+      if (!cloudResource.labels || cloudResource.labels.length === 0) {
+        return false;
+      }
+      const ruleLabelIds: Array<string> = rule.matchLabels.map((l: Label) => {
+        return l.id?.toString() || "";
+      });
+      const labelIds: Array<string> = cloudResource.labels.map((l: Label) => {
+        return l.id?.toString() || "";
+      });
+      if (
+        !ruleLabelIds.some((id: string) => {
+          return labelIds.includes(id);
+        })
+      ) {
+        return false;
+      }
+    }
+
+    if (
+      rule.nameRegexPattern &&
+      (!cloudResource.name ||
+        !this.testRegex(rule.nameRegexPattern, cloudResource.name))
+    ) {
+      return false;
+    }
+
+    if (
+      rule.descriptionRegexPattern &&
+      (!cloudResource.description ||
+        !this.testRegex(rule.descriptionRegexPattern, cloudResource.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 cloud resource owner rule: ${pattern}`);
+      return false;
+    }
+  }
+}
+
+export default new CloudResourceOwnerRuleEngineServiceClass();

package/Server/Services/CloudResourceOwnerRuleService.ts

@@ -0,0 +1,14 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/CloudResourceOwnerRule";
+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();

package/Server/Services/CloudResourceOwnerTeamService.ts

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

package/Server/Services/CloudResourceOwnerUserService.ts

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