@oneuptime/common 11.5.4 → 11.5.5

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>,

package/Server/Services/IncidentService.ts

@@ -6,6 +6,9 @@ import FindBy from "../Types/Database/FindBy";
 import { OnCreate, OnDelete, OnFind, OnUpdate } from "../Types/Database/Hooks";
 import QueryHelper from "../Types/Database/QueryHelper";
 import DatabaseService from "./DatabaseService";
+import AIRunService from "./AIRunService";
+import AIRunType from "../../Types/AI/AIRunType";
+import AIRunStatus from "../../Types/AI/AIRunStatus";
 import IncidentOwnerTeamService from "./IncidentOwnerTeamService";
 import IncidentOwnerUserService from "./IncidentOwnerUserService";
 import IncidentStateService from "./IncidentStateService";
@@ -84,7 +87,7 @@ import ProjectService from "./ProjectService";
 import IncidentTemplateService from "./IncidentTemplateService";
 import IncidentTemplate from "../../Models/DatabaseModels/IncidentTemplate";
 import AIService, { AILogResponse } from "./AIService";
-import SentinelIncidentInvestigationRunner from "../Utils/AI/Sentinel/IncidentInvestigationRunner";
+import AIIncidentInvestigationRunner from "../Utils/AI/SRE/IncidentInvestigationRunner";
 import IncidentAIContextBuilder, {
   AIGenerationContext,
   IncidentContextData,
@@ -1239,21 +1242,21 @@ export class Service extends DatabaseService<Model> {
       })
       .then(async () => {
         /*
-         * Sentinel (AI SRE): automatically investigate the new incident and post
+         * AI (AI SRE): automatically investigate the new incident and post
          * a cited root cause analysis to the incident timeline + Slack/Teams.
          * Runs last so the workspace channels already exist, and is gated per
          * project (opt-in) + requires a configured LLM provider. Read-only.
          */
         try {
           if (createdItem.projectId && createdItem.id) {
-            await SentinelIncidentInvestigationRunner.investigateNewIncident({
+            await AIIncidentInvestigationRunner.investigateNewIncident({
               incidentId: createdItem.id,
               projectId: createdItem.projectId,
             });
           }
         } catch (error) {
           logger.error(
-            `Sentinel incident investigation failed in IncidentService.onCreateSuccess: ${error}`,
+            `AI incident investigation failed in IncidentService.onCreateSuccess: ${error}`,
             {
               projectId: createdItem.projectId?.toString(),
               incidentId: createdItem.id?.toString(),
@@ -2795,14 +2798,23 @@ ${incidentSeverity.name}
     return Service.DEFAULT_METRIC_RETENTION_DAYS;
   }
 
+  /*
+   * Load the incident + its owners and build the attribute set shared by
+   * every incident metric (all values strings for ClickHouse
+   * Map(String, String) storage; arrays joined comma-separated). Factored
+   * out of refreshIncidentMetrics so one-off metric writers — e.g. the
+   * AI time-to-rca metric recorded when an investigation posts its
+   * analysis — record the exact same attribute shape.
+   */
   @CaptureSpan()
-  public async refreshIncidentMetrics(data: {
+  public async getIncidentMetricContext(data: {
     incidentId: ObjectID;
-  }): Promise<void> {
+  }): Promise<{ incident: Model; baseMetricAttributes: JSONObject }> {
     const incident: Model | null = await this.findOneById({
       id: data.incidentId,
       select: {
         projectId: true,
+        createdAt: true,
         declaredAt: true,
         postmortemPostedAt: true,
         monitors: {
@@ -2898,6 +2910,161 @@ ${incidentSeverity.name}
         return Boolean(name);
       }) as Array<string>;
 
+    /*
+     * common attributes shared by all incident metrics
+     * All values must be strings for ClickHouse Map(String, String) storage.
+     * Arrays are joined as comma-separated strings.
+     */
+    const baseMetricAttributes: JSONObject = {
+      incidentId: data.incidentId.toString(),
+      projectId: incident.projectId.toString(),
+      monitorIds: (
+        incident.monitors
+          ?.map((monitor: Monitor) => {
+            return monitor._id?.toString();
+          })
+          .filter(Boolean) || []
+      ).join(", "),
+      monitorNames: (
+        incident.monitors
+          ?.map((monitor: Monitor) => {
+            return monitor.name?.toString();
+          })
+          .filter(Boolean) || []
+      ).join(", "),
+      incidentSeverityId: incident.incidentSeverity?._id?.toString(),
+      incidentSeverityName: incident.incidentSeverity?.name?.toString(),
+      ownerUserIds: ownerUserIds.join(", "),
+      ownerUserNames: ownerUserNames.join(", "),
+      ownerTeamIds: ownerTeamIds.join(", "),
+      ownerTeamNames: ownerTeamNames.join(", "),
+    };
+
+    return { incident, baseMetricAttributes };
+  }
+
+  /*
+   * AI measurement layer: record how long the incident waited for its
+   * AI root-cause analysis — seconds from incident creation to now, written
+   * once from IncidentInvestigationRunner.postAnalysis. Deliberately NOT
+   * part of refreshIncidentMetrics: the refresh's replace-list excludes
+   * this metric name, so refreshes never tombstone it.
+   */
+  @CaptureSpan()
+  public async recordTimeToRootCausePostedMetric(data: {
+    incidentId: ObjectID;
+  }): Promise<void> {
+    const {
+      incident,
+      baseMetricAttributes,
+    }: { incident: Model; baseMetricAttributes: JSONObject } =
+      await this.getIncidentMetricContext({ incidentId: data.incidentId });
+
+    const now: Date = OneUptimeDate.getCurrentDate();
+    const incidentCreatedAt: Date =
+      incident.createdAt || incident.declaredAt || now;
+
+    const metricRetentionDays: number = await this.getMetricRetentionDays();
+    const retentionDate: Date = OneUptimeDate.addRemoveDays(
+      OneUptimeDate.getCurrentDate(),
+      metricRetentionDays,
+    );
+
+    const timeToRcaMetric: MutableMetric = new MutableMetric();
+
+    timeToRcaMetric.projectId = incident.projectId!;
+    timeToRcaMetric.primaryEntityId = incident.id!;
+    timeToRcaMetric.primaryEntityType = ServiceType.Incident;
+    timeToRcaMetric.name = IncidentMetricType.TimeToRootCausePosted;
+    timeToRcaMetric.metricPointId = IncidentMetricType.TimeToRootCausePosted;
+    timeToRcaMetric.value = OneUptimeDate.getDifferenceInSeconds(
+      now,
+      incidentCreatedAt,
+    );
+    timeToRcaMetric.attributes = {
+      ...baseMetricAttributes,
+      // Every time-to-rca point is AI-posted by construction.
+      aiInvestigated: "true",
+    };
+    timeToRcaMetric.attributeKeys = TelemetryUtil.getAttributeKeys(
+      timeToRcaMetric.attributes,
+    );
+    timeToRcaMetric.time = now;
+    timeToRcaMetric.timeUnixNano = OneUptimeDate.toUnixNano(now);
+    timeToRcaMetric.metricPointType = MetricPointType.Sum;
+    timeToRcaMetric.retentionDate = retentionDate;
+
+    await MutableMetricService.createMutableMetrics({
+      metrics: [timeToRcaMetric],
+    });
+
+    // Register the metric type so it shows up in the type catalog.
+    const metricType: MetricType = new MetricType();
+    metricType.name = IncidentMetricType.TimeToRootCausePosted;
+    metricType.description =
+      "Time from incident creation to the AI investigation's posted root-cause analysis";
+    metricType.unit = "seconds";
+
+    TelemetryUtil.indexMetricNameServiceNameMap({
+      metricNameServiceNameMap: {
+        [IncidentMetricType.TimeToRootCausePosted]: metricType,
+      },
+      projectId: incident.projectId!,
+    }).catch((err: Error) => {
+      logger.error(err, {
+        projectId: incident.projectId?.toString(),
+        incidentId: incident.id?.toString(),
+      } as LogAttributes);
+    });
+  }
+
+  @CaptureSpan()
+  public async refreshIncidentMetrics(data: {
+    incidentId: ObjectID;
+  }): Promise<void> {
+    const {
+      incident,
+      baseMetricAttributes,
+    }: { incident: Model; baseMetricAttributes: JSONObject } =
+      await this.getIncidentMetricContext({ incidentId: data.incidentId });
+
+    // getIncidentMetricContext guarantees this; re-checked for TS narrowing.
+    if (!incident.projectId) {
+      throw new BadDataException("Incident Project ID not found");
+    }
+
+    /*
+     * aiInvestigated dimension for MTTA/MTTR (AI measurement layer):
+     * did a completed AI investigation run for this incident? One
+     * indexed countBy per metric refresh (triggeredByIncidentId is indexed)
+     * — acceptable at refresh frequency. Failure must never break metric
+     * recording, so this is best-effort false.
+     */
+    let aiInvestigated: boolean = false;
+    try {
+      const completedInvestigationCount: PositiveNumber =
+        await AIRunService.countBy({
+          query: {
+            runType: AIRunType.Investigation,
+            status: AIRunStatus.Completed,
+            triggeredByIncidentId: data.incidentId,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+      aiInvestigated = completedInvestigationCount.toNumber() > 0;
+    } catch (err) {
+      logger.error(
+        err as Error,
+        {
+          projectId: incident.projectId?.toString(),
+          incidentId: incident.id?.toString(),
+        } as LogAttributes,
+      );
+    }
+
     // get incident state timeline
 
     const incidentStateTimelines: Array<IncidentStateTimeline> =
@@ -2973,36 +3140,6 @@ ${incidentSeverity.name}
 
       const metricTypesMap: Dictionary<MetricType> = {};
 
-      /*
-       * common attributes shared by all incident metrics
-       * All values must be strings for ClickHouse Map(String, String) storage.
-       * Arrays are joined as comma-separated strings.
-       */
-      const baseMetricAttributes: JSONObject = {
-        incidentId: data.incidentId.toString(),
-        projectId: incident.projectId.toString(),
-        monitorIds: (
-          incident.monitors
-            ?.map((monitor: Monitor) => {
-              return monitor._id?.toString();
-            })
-            .filter(Boolean) || []
-        ).join(", "),
-        monitorNames: (
-          incident.monitors
-            ?.map((monitor: Monitor) => {
-              return monitor.name?.toString();
-            })
-            .filter(Boolean) || []
-        ).join(", "),
-        incidentSeverityId: incident.incidentSeverity?._id?.toString(),
-        incidentSeverityName: incident.incidentSeverity?.name?.toString(),
-        ownerUserIds: ownerUserIds.join(", "),
-        ownerUserNames: ownerUserNames.join(", "),
-        ownerTeamIds: ownerTeamIds.join(", "),
-        ownerTeamNames: ownerTeamNames.join(", "),
-      };
-
       const incidentCountMetric: MutableMetric = new MutableMetric();
 
       incidentCountMetric.projectId = incident.projectId;
@@ -3068,7 +3205,11 @@ ${incidentSeverity.name}
               OneUptimeDate.getCurrentDate(),
             incidentStartsAt,
           );
-          timeToAcknowledgeMetric.attributes = { ...baseMetricAttributes };
+          // aiInvestigated: the MTTA with/without-AI dimension.
+          timeToAcknowledgeMetric.attributes = {
+            ...baseMetricAttributes,
+            aiInvestigated: aiInvestigated.toString(),
+          };
           timeToAcknowledgeMetric.attributeKeys =
             TelemetryUtil.getAttributeKeys(timeToAcknowledgeMetric.attributes);
 
@@ -3119,7 +3260,11 @@ ${incidentSeverity.name}
             OneUptimeDate.getCurrentDate(),
           incidentStartsAt,
         );
-        timeToResolveMetric.attributes = { ...baseMetricAttributes };
+        // aiInvestigated: the MTTR with/without-AI dimension.
+        timeToResolveMetric.attributes = {
+          ...baseMetricAttributes,
+          aiInvestigated: aiInvestigated.toString(),
+        };
         timeToResolveMetric.attributeKeys = TelemetryUtil.getAttributeKeys(
           timeToResolveMetric.attributes,
         );