@oneuptime/common 11.5.4 → 11.5.6

package/Server/Services/AlertService.ts

@@ -67,7 +67,7 @@ import AlertLabelRuleEngineService from "./AlertLabelRuleEngineService";
 import AlertOnCallRuleEngineService from "./AlertOnCallRuleEngineService";
 import AlertOwnerRuleEngineService from "./AlertOwnerRuleEngineService";
 import RunbookRuleEngineService from "./RunbookRuleEngineService";
-import SentinelAlertInvestigationRunner from "../Utils/AI/Sentinel/AlertInvestigationRunner";
+import AIAlertInvestigationRunner from "../Utils/AI/SRE/AlertInvestigationRunner";
 import AlertPrivacyRuleEngineService from "./AlertPrivacyRuleEngineService";
 import ProjectService from "./ProjectService";
 
@@ -561,21 +561,21 @@ export class Service extends DatabaseService<Model> {
       })
       .then(async () => {
         /*
-         * Sentinel (AI SRE): automatically investigate the new alert and post a
+         * AI (AI SRE): automatically investigate the new alert and post a
          * cited root cause analysis to the alert timeline + Slack/Teams. Runs
          * last, is gated per project (opt-in) + requires an LLM provider, and is
          * read-only.
          */
         try {
           if (createdItem.projectId && createdItem.id) {
-            await SentinelAlertInvestigationRunner.investigateNewAlert({
+            await AIAlertInvestigationRunner.investigateNewAlert({
               alertId: createdItem.id,
               projectId: createdItem.projectId,
             });
           }
         } catch (error) {
           logger.error(
-            `Sentinel alert investigation failed in AlertService.onCreateSuccess: ${error}`,
+            `AI alert investigation failed in AlertService.onCreateSuccess: ${error}`,
             {
               projectId: createdItem.projectId?.toString(),
               alertId: createdItem.id?.toString(),

package/Server/Services/CodeRepositoryService.ts

@@ -1,10 +1,219 @@
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/CodeRepository";
+import ObjectID from "../../Types/ObjectID";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import CodeRepositoryType from "../../Types/CodeRepository/CodeRepositoryType";
+import URL from "../../Types/API/URL";
+import logger from "../Utils/Logger";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import {
+  RepoResolution,
+  ResolvableRepository,
+  resolveRepositoryForExceptionFix,
+} from "../Utils/CodeRepository/StackTraceRepoResolver";
+import GitHubUtil, {
+  GitHubRepository,
+} from "../Utils/CodeRepository/GitHub/GitHub";
+
+export interface ImportReposFromInstallationResult {
+  imported: number;
+  skipped: number;
+}
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  /*
+   * Imports all repositories accessible to a GitHub App installation into a
+   * project. Repositories that already exist for the project (matched on
+   * organizationName + repositoryName) are skipped. Never deletes anything.
+   */
+  @CaptureSpan()
+  public async importReposFromInstallation(data: {
+    projectId: ObjectID;
+    installationId: string;
+  }): Promise<ImportReposFromInstallationResult> {
+    const installationRepositories: Array<GitHubRepository> =
+      await GitHubUtil.listRepositoriesForInstallation(data.installationId);
+
+    // Fetch existing repositories once so we can skip duplicates and de-dupe display names.
+    const existingRepositories: Array<Model> = await this.findBy({
+      query: {
+        projectId: data.projectId,
+      },
+      select: {
+        _id: true,
+        name: true,
+        organizationName: true,
+        repositoryName: true,
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    const existingRepositoryKeys: Set<string> = new Set<string>(
+      existingRepositories.map((repository: Model) => {
+        return `${repository.organizationName?.toLowerCase()}/${repository.repositoryName?.toLowerCase()}`;
+      }),
+    );
+
+    const existingDisplayNames: Set<string> = new Set<string>(
+      existingRepositories
+        .map((repository: Model) => {
+          return repository.name?.toLowerCase() || "";
+        })
+        .filter((name: string) => {
+          return Boolean(name);
+        }),
+    );
+
+    let imported: number = 0;
+    let skipped: number = 0;
+
+    for (const repository of installationRepositories) {
+      const repositoryKey: string = `${repository.ownerLogin.toLowerCase()}/${repository.name.toLowerCase()}`;
+
+      if (existingRepositoryKeys.has(repositoryKey)) {
+        skipped++;
+        continue;
+      }
+
+      /*
+       * Display name is unique per project. If a repository with the same
+       * name exists (e.g. same repo name in a different org), fall back to
+       * the org-qualified name, then a numeric suffix.
+       */
+      let displayName: string = repository.name;
+
+      if (existingDisplayNames.has(displayName.toLowerCase())) {
+        displayName = repository.fullName;
+      }
+
+      let suffix: number = 2;
+
+      while (existingDisplayNames.has(displayName.toLowerCase())) {
+        displayName = `${repository.fullName} (${suffix})`;
+        suffix++;
+      }
+
+      const codeRepository: Model = new Model();
+      codeRepository.projectId = data.projectId;
+      codeRepository.name = displayName;
+      codeRepository.repositoryHostedAt = CodeRepositoryType.GitHub;
+      codeRepository.organizationName = repository.ownerLogin;
+      codeRepository.repositoryName = repository.name;
+      codeRepository.mainBranchName = repository.defaultBranch || "main";
+      codeRepository.gitHubAppInstallationId = data.installationId;
+
+      if (repository.htmlUrl) {
+        codeRepository.repositoryUrl = URL.fromString(repository.htmlUrl);
+      }
+
+      if (repository.description) {
+        codeRepository.description = repository.description;
+      }
+
+      try {
+        await this.create({
+          data: codeRepository,
+          props: {
+            isRoot: true,
+          },
+        });
+
+        existingRepositoryKeys.add(repositoryKey);
+        existingDisplayNames.add(displayName.toLowerCase());
+        imported++;
+      } catch (error) {
+        // One bad repository should not abort the whole import.
+        logger.error(
+          `Failed to import repository ${repository.fullName} from GitHub App installation ${data.installationId} into project ${data.projectId.toString()}:`,
+        );
+        logger.error(error);
+        skipped++;
+      }
+    }
+
+    return { imported, skipped };
+  }
+
+  /*
+   * Resolve which of the project's repositories an exception's code lives
+   * in, AT RUNTIME — stack-trace path matching over cached git trees, with
+   * exact-name-match and only-repository fallbacks. This replaces the old
+   * manual ServiceCodeRepository mapping table.
+   */
+  @CaptureSpan()
+  public async resolveRepositoryForException(data: {
+    projectId: ObjectID;
+    stackTrace: string | null;
+    serviceName: string | null;
+  }): Promise<RepoResolution | null> {
+    const repositories: Array<Model> = await this.findBy({
+      query: {
+        projectId: data.projectId,
+      },
+      select: {
+        _id: true,
+        name: true,
+        organizationName: true,
+        repositoryName: true,
+        mainBranchName: true,
+        gitHubAppInstallationId: true,
+        repositoryHostedAt: true,
+      },
+      skip: 0,
+      limit: LIMIT_MAX,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    // Only GitHub-App-connected repos can be cloned/pushed by the agent.
+    const resolvable: Array<ResolvableRepository> = repositories
+      .filter((repository: Model) => {
+        return (
+          repository.repositoryHostedAt === CodeRepositoryType.GitHub &&
+          Boolean(repository.gitHubAppInstallationId) &&
+          Boolean(repository.id)
+        );
+      })
+      .map((repository: Model) => {
+        return {
+          id: repository.id!.toString(),
+          name: repository.name || "",
+          organizationName: repository.organizationName || "",
+          repositoryName: repository.repositoryName || "",
+          mainBranchName: repository.mainBranchName || "main",
+          gitHubAppInstallationId: repository.gitHubAppInstallationId || null,
+        };
+      });
+
+    if (resolvable.length === 0) {
+      return null;
+    }
+
+    return resolveRepositoryForExceptionFix({
+      stackTrace: data.stackTrace,
+      serviceName: data.serviceName,
+      repositories: resolvable,
+      getTreePaths: (
+        repository: ResolvableRepository,
+      ): Promise<Array<string>> => {
+        return GitHubUtil.getRepositoryTreePaths({
+          installationId: repository.gitHubAppInstallationId!,
+          organizationName: repository.organizationName,
+          repositoryName: repository.repositoryName,
+          branchName: repository.mainBranchName,
+        });
+      },
+    });
+  }
 }
 
 export default new Service();

package/Server/Services/GlobalConfigService.ts

@@ -4,6 +4,8 @@ import InMemoryTTLCache from "../Infrastructure/InMemoryTTLCache";
 import ObjectID from "../../Types/ObjectID";
 import { OnUpdate } from "../Types/Database/Hooks";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import UpdateBy from "../Types/Database/UpdateBy";
+import BadDataException from "../../Types/Exception/BadDataException";
 
 export class Service extends DatabaseService<Model> {
   /*
@@ -41,6 +43,152 @@ export class Service extends DatabaseService<Model> {
     return value;
   }
 
+  @CaptureSpan()
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    const capacitySettingKeys: Array<keyof Model> = [
+      "clickhouseCapacityNotificationEnabled",
+      "clickhouseCapacityNotificationThresholdPercent",
+      "clickhouseDataPruningEnabled",
+      "clickhouseDataPruningThresholdPercent",
+      "clickhouseDataPruningTargetPercent",
+    ];
+
+    const isCapacitySettingUpdate: boolean = capacitySettingKeys.some(
+      (key: keyof Model): boolean => {
+        return updateBy.data[key] !== undefined;
+      },
+    );
+
+    if (!isCapacitySettingUpdate) {
+      return {
+        updateBy,
+        carryForward: null,
+      };
+    }
+
+    /*
+     * GlobalConfig updates are partial. Load the current singleton values so
+     * cross-field validation still compares the effective pruning threshold
+     * and target when the request changes only one of them.
+     */
+    const currentConfig: Model | null = await this.findOneBy({
+      query: updateBy.query,
+      select: {
+        clickhouseCapacityNotificationThresholdPercent: true,
+        clickhouseDataPruningThresholdPercent: true,
+        clickhouseDataPruningTargetPercent: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    const normalizePercent: (value: unknown, fieldName: string) => number = (
+      value: unknown,
+      fieldName: string,
+    ): number => {
+      let normalizedValue: unknown = value;
+
+      if (typeof normalizedValue === "string") {
+        const trimmedValue: string = normalizedValue.trim();
+        normalizedValue =
+          trimmedValue === "" ? Number.NaN : Number(trimmedValue);
+      }
+
+      if (
+        typeof normalizedValue !== "number" ||
+        !Number.isFinite(normalizedValue) ||
+        !Number.isInteger(normalizedValue) ||
+        normalizedValue < 1 ||
+        normalizedValue > 100
+      ) {
+        throw new BadDataException(
+          `${fieldName} must be an integer between 1 and 100.`,
+        );
+      }
+
+      return normalizedValue;
+    };
+
+    if (
+      updateBy.data.clickhouseCapacityNotificationThresholdPercent !== undefined
+    ) {
+      updateBy.data.clickhouseCapacityNotificationThresholdPercent =
+        normalizePercent(
+          updateBy.data
+            .clickhouseCapacityNotificationThresholdPercent as unknown,
+          "ClickHouse capacity notification threshold",
+        );
+    }
+
+    if (updateBy.data.clickhouseDataPruningThresholdPercent !== undefined) {
+      updateBy.data.clickhouseDataPruningThresholdPercent = normalizePercent(
+        updateBy.data.clickhouseDataPruningThresholdPercent as unknown,
+        "ClickHouse data pruning threshold",
+      );
+    }
+
+    if (updateBy.data.clickhouseDataPruningTargetPercent !== undefined) {
+      updateBy.data.clickhouseDataPruningTargetPercent = normalizePercent(
+        updateBy.data.clickhouseDataPruningTargetPercent as unknown,
+        "ClickHouse data pruning target",
+      );
+    }
+
+    const getEffectivePercent: (
+      updatedValue: unknown,
+      currentValue: number | undefined,
+      defaultValue: number,
+      fieldName: string,
+    ) => number = (
+      updatedValue: unknown,
+      currentValue: number | undefined,
+      defaultValue: number,
+      fieldName: string,
+    ): number => {
+      const value: unknown =
+        updatedValue !== undefined
+          ? updatedValue
+          : currentValue ?? defaultValue;
+
+      return normalizePercent(value, fieldName);
+    };
+
+    getEffectivePercent(
+      updateBy.data.clickhouseCapacityNotificationThresholdPercent,
+      currentConfig?.clickhouseCapacityNotificationThresholdPercent,
+      80,
+      "ClickHouse capacity notification threshold",
+    );
+
+    const pruningThresholdPercent: number = getEffectivePercent(
+      updateBy.data.clickhouseDataPruningThresholdPercent,
+      currentConfig?.clickhouseDataPruningThresholdPercent,
+      90,
+      "ClickHouse data pruning threshold",
+    );
+
+    const pruningTargetPercent: number = getEffectivePercent(
+      updateBy.data.clickhouseDataPruningTargetPercent,
+      currentConfig?.clickhouseDataPruningTargetPercent,
+      80,
+      "ClickHouse data pruning target",
+    );
+
+    if (pruningTargetPercent >= pruningThresholdPercent) {
+      throw new BadDataException(
+        "ClickHouse data pruning target must be lower than the pruning threshold.",
+      );
+    }
+
+    return {
+      updateBy,
+      carryForward: null,
+    };
+  }
+
   @CaptureSpan()
   protected override async onUpdateSuccess(
     onUpdate: OnUpdate<Model>,