@oneuptime/common 11.5.4 → 11.5.5

package/Server/Services/IncidentStateTimelineService.ts

@@ -27,7 +27,8 @@ import IncidentRole from "../../Models/DatabaseModels/IncidentRole";
 import { IsBillingEnabled } from "../EnvironmentConfig";
 import logger, { LogAttributes } from "../Utils/Logger";
 import IncidentFeedService from "./IncidentFeedService";
-import SentinelIncidentPostmortemRunner from "../Utils/AI/Sentinel/IncidentPostmortemRunner";
+import AIIncidentPostmortemRunner from "../Utils/AI/SRE/IncidentPostmortemRunner";
+import InvestigationGrader from "../Utils/AI/SRE/InvestigationGrader";
 import { IncidentFeedEventType } from "../../Models/DatabaseModels/IncidentFeed";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
@@ -558,14 +559,33 @@ ${createdItem.rootCause}`,
       }
 
       /*
-       * Sentinel: auto-draft a postmortem now that the incident is resolved
+       * AI: auto-draft a postmortem now that the incident is resolved
        * (gated per project; never overwrites an existing postmortem).
        */
-      SentinelIncidentPostmortemRunner.draftPostmortemOnResolve({
+      AIIncidentPostmortemRunner.draftPostmortemOnResolve({
         incidentId: createdItem.incidentId!,
         projectId: createdItem.projectId!,
       }).catch((error: Error) => {
-        logger.error(`Sentinel auto-postmortem failed on resolve:`, {
+        logger.error(`AI auto-postmortem failed on resolve:`, {
+          projectId: createdItem.projectId?.toString(),
+          incidentId: createdItem.incidentId?.toString(),
+        } as LogAttributes);
+        logger.error(error, {
+          projectId: createdItem.projectId?.toString(),
+          incidentId: createdItem.incidentId?.toString(),
+        } as LogAttributes);
+      });
+
+      /*
+       * AI measurement layer: grade the completed investigation (if
+       * any) against the human-recorded root cause. Fire-and-forget like
+       * the postmortem draft above — must never block or fail the resolve.
+       */
+      InvestigationGrader.gradeInvestigationOnResolve({
+        incidentId: createdItem.incidentId!,
+        projectId: createdItem.projectId!,
+      }).catch((error: Error) => {
+        logger.error(`AI investigation grading failed on resolve:`, {
           projectId: createdItem.projectId?.toString(),
           incidentId: createdItem.incidentId?.toString(),
         } as LogAttributes);

package/Server/Services/Index.ts

@@ -13,6 +13,7 @@ import CallLogService from "./CallLogService";
 import CallService from "./CallService";
 import DataMigrationService from "./DataMigrationService";
 import MigrationFailureService from "./MigrationFailureService";
+import InstanceHealthLogService from "./InstanceHealthLogService";
 import DomainService from "./DomainService";
 import EmailLogService from "./EmailLogService";
 import EmailVerificationTokenService from "./EmailVerificationTokenService";
@@ -81,6 +82,7 @@ import MonitorOwnerUserService from "./MonitorOwnerUserService";
 import MonitorProbeService from "./MonitorProbeService";
 import MonitorSecretService from "./MonitorSecretService";
 import RunbookSecretService from "./RunbookSecretService";
+import AIInsightService from "./AIInsightService";
 
 // Monitors
 import MonitorService from "./MonitorService";
@@ -104,7 +106,6 @@ import ProbeService from "./ProbeService";
 import AIAgentService from "./AIAgentService";
 import AIAgentOwnerUserService from "./AIAgentOwnerUserService";
 import AIAgentOwnerTeamService from "./AIAgentOwnerTeamService";
-import AIAgentTaskLogService from "./AIAgentTaskLogService";
 import AIAgentTaskPullRequestService from "./AIAgentTaskPullRequestService";
 import ProjectCallSMSConfigService from "./ProjectCallSMSConfigService";
 import ProjectService from "./ProjectService";
@@ -137,7 +138,6 @@ import ScheduledMaintenanceStateTimelineService from "./ScheduledMaintenanceStat
 import ServiceOwnerTeamService from "./ServiceOwnerTeamService";
 import ServiceOwnerUserService from "./ServiceOwnerUserService";
 import ServiceService from "./ServiceService";
-import ServiceCodeRepositoryService from "./ServiceCodeRepositoryService";
 import ShortLinkService from "./ShortLinkService";
 // SMS Log Service
 import SmsLogService from "./SmsLogService";
@@ -282,6 +282,7 @@ const services: Array<BaseService> = [
 
   DataMigrationService,
   MigrationFailureService,
+  InstanceHealthLogService,
   DomainService,
 
   EmailLogService,
@@ -346,6 +347,7 @@ const services: Array<BaseService> = [
   MonitorStatusTimelineService,
   MonitorSecretService,
   RunbookSecretService,
+  AIInsightService,
   MonitorFeedService,
 
   NotificationService,
@@ -365,7 +367,6 @@ const services: Array<BaseService> = [
   AIAgentService,
   AIAgentOwnerUserService,
   AIAgentOwnerTeamService,
-  AIAgentTaskLogService,
   AIAgentTaskPullRequestService,
   ProjectSsoService,
   ProjectOidcService,
@@ -456,7 +457,6 @@ const services: Array<BaseService> = [
   ServiceService,
   ServiceOwnerTeamService,
   ServiceOwnerUserService,
-  ServiceCodeRepositoryService,
 
   TelemetryExceptionService,
   TelemetryEntityService,

package/Server/Services/{AIAgentTaskLogService.ts → InstanceHealthLogService.ts}

@@ -1,5 +1,5 @@
 import DatabaseService from "./DatabaseService";
-import Model from "../../Models/DatabaseModels/AIAgentTaskLog";
+import Model from "../../Models/DatabaseModels/InstanceHealthLog";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {

package/Server/Services/LlmLogService.ts

@@ -35,6 +35,33 @@ export class Service extends DatabaseService<Model> {
 
     return Number(rows[0]?.total || 0);
   }
+
+  /*
+   * Per-run LLM usage for the server-mediated code-fix agent loop budgets
+   * (B4 Tier 0): how many completion calls a run has made and how many
+   * output tokens they produced. One SQL aggregate over the run's LlmLog
+   * rows — executeWithLogging writes exactly one row per call (success,
+   * error, or budget rejection), so the count is the honest call count and
+   * errored calls conservatively consume a slot. Runs are bounded to ~30
+   * minutes, far inside the 3-day cloud LlmLog retention.
+   */
+  @CaptureSpan()
+  public async getRunCompletionUsage(data: {
+    aiRunId: ObjectID;
+  }): Promise<{ completionCalls: number; outputTokens: number }> {
+    const rows: Array<{
+      calls: string | number | null;
+      outputTokens: string | number | null;
+    }> = await this.getRepository().manager.query(
+      `SELECT COUNT(*) AS "calls", COALESCE(SUM("completionTokens"), 0) AS "outputTokens" FROM "LlmLog" WHERE "aiRunId" = $1 AND "deletedAt" IS NULL`,
+      [data.aiRunId.toString()],
+    );
+
+    return {
+      completionCalls: Number(rows[0]?.calls || 0),
+      outputTokens: Number(rows[0]?.outputTokens || 0),
+    };
+  }
 }
 
 export default new Service();

package/Server/Services/LlmProviderService.ts

@@ -157,6 +157,114 @@ export class Service extends DatabaseService<Model> {
     return null;
   }
 
+  /*
+   * Resolve a provider the project OWNS — never the global fallback.
+   * Callers that may also use the shared global provider layer that
+   * fallback themselves (see getLlmProviderForMeteredAgentPath). Prefers
+   * the project default, else any project-owned provider.
+   */
+  @CaptureSpan()
+  public async getProjectOwnedLlmProvider(
+    projectId: ObjectID,
+  ): Promise<Model | null> {
+    const select: {
+      _id: boolean;
+      name: boolean;
+      llmType: boolean;
+      apiKey: boolean;
+      baseUrl: boolean;
+      modelName: boolean;
+      additionalParams: boolean;
+      isGlobalLlm: boolean;
+      costPerMillionTokensInUSDCents: boolean;
+    } = {
+      _id: true,
+      name: true,
+      llmType: true,
+      apiKey: true,
+      baseUrl: true,
+      modelName: true,
+      additionalParams: true,
+      isGlobalLlm: true,
+      costPerMillionTokensInUSDCents: true,
+    };
+
+    const defaultProvider: Model | null = await this.findOneBy({
+      query: {
+        projectId: projectId,
+        isDefault: true,
+      },
+      select,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (defaultProvider) {
+      return defaultProvider;
+    }
+
+    return this.findOneBy({
+      query: {
+        projectId: projectId,
+      },
+      sort: {
+        createdAt: SortOrder.Ascending,
+      },
+      select,
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
+  /*
+   * Resolve the provider for the METERED agent path (B4 Tier 0): the
+   * server-mediated /ai-agent-data/llm-completion endpoint, whose calls run
+   * through AIService.executeWithLogging — logged to LlmLog, billed when the
+   * global provider is costed, and inside the daily autonomous token budget.
+   *
+   * Because metering is universal on this path, a project-owned provider
+   * still wins, but when the project owns none the shared global provider
+   * is returned ON CLOUD TOO — its usage is billed as metered AI tokens.
+   * Cloud zero-config completes: fix tasks work with no per-project
+   * provider. (The old raw-key path — get-llm-config handing the provider
+   * apiKey to the worker for unmetered direct calls — is removed; this is
+   * the only agent provider resolution left.)
+   */
+  @CaptureSpan()
+  public async getLlmProviderForMeteredAgentPath(
+    projectId: ObjectID,
+  ): Promise<Model | null> {
+    const projectOwnedProvider: Model | null =
+      await this.getProjectOwnedLlmProvider(projectId);
+
+    if (projectOwnedProvider) {
+      return projectOwnedProvider;
+    }
+
+    return this.findOneBy({
+      query: {
+        projectId: QueryHelper.isNull(),
+        isGlobalLlm: true,
+      },
+      select: {
+        _id: true,
+        name: true,
+        llmType: true,
+        apiKey: true,
+        baseUrl: true,
+        modelName: true,
+        additionalParams: true,
+        isGlobalLlm: true,
+        costPerMillionTokensInUSDCents: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
   /*
    * Resolve the provider to use for a chat turn. When the user has explicitly
    * chosen a provider (llmProviderId), use it — but only if it is actually

package/Server/Services/MetricBaselineService.ts

@@ -44,6 +44,20 @@ export interface BandPoint {
   expectedLow: number;
 }
 
+/**
+ * One (metric, entity) cell's finalized mean/sample-count for one of the
+ * two week-over-week drift windows. The AI MetricDrift detector
+ * joins the "recent" and "prior" rows in JS (the join stays app-side so
+ * the drift decision is a pure, unit-testable function).
+ */
+export interface MetricDriftWindowRow {
+  name: string;
+  primaryEntityId: string;
+  mean: number;
+  sampleCount: number;
+  window: "recent" | "prior";
+}
+
 /**
  * Read-side service for the `MetricBaselineHourly` MV target table.
  *
@@ -96,6 +110,14 @@ export class MetricBaselineService extends AnalyticsDatabaseService<MetricBaseli
   public static readonly WINDOW_DAYS_OPTIONS: ReadonlyArray<number> = [
     14, 28, 60, 90,
   ];
+  /**
+   * Hard cap on rows returned per drift window. Params travel in the
+   * ClickHouse HTTP URI and the detector joins both windows in JS, so an
+   * unbounded GROUP BY over a high-cardinality tenant would be both a
+   * memory and a transfer problem. Ranked by sampleCount so the busiest
+   * (most statistically trustworthy) cells always make the cut.
+   */
+  public static readonly DRIFT_MAX_ROWS_PER_WINDOW: number = 500;
 
   /**
    * Fetch the rolling-window baseline for one (metric, [entity],
@@ -285,6 +307,107 @@ export class MetricBaselineService extends AnalyticsDatabaseService<MetricBaseli
     return { totalSamples, oldestDay };
   }
 
+  /**
+   * Week-over-week drift feed for the AI MetricDrift detector: the
+   * finalized mean + sample count per (metric name, entity) cell for two
+   * adjacent 7-day windows — "recent" (last 7 days including today) and
+   * "prior" (the 7 days before that). Two GROUP BY finalization queries
+   * over the MetricBaselineHourly states (same *Merge idiom as
+   * getBaseline); the recent/prior JOIN deliberately happens in the
+   * caller's pure decision function, not in SQL, so it is unit-testable.
+   * Each window is capped at `limitPerWindow` rows (≤
+   * DRIFT_MAX_ROWS_PER_WINDOW) ranked by sampleCount descending.
+   */
+  public async getWeekOverWeekDrift(data: {
+    projectId: ObjectID;
+    limitPerWindow: number;
+  }): Promise<Array<MetricDriftWindowRow>> {
+    const projectIdStr: string = this.escapeString(data.projectId.toString());
+    const limit: number = Math.max(
+      1,
+      Math.min(
+        Math.floor(data.limitPerWindow),
+        MetricBaselineService.DRIFT_MAX_ROWS_PER_WINDOW,
+      ),
+    );
+
+    const windows: Array<{ window: "recent" | "prior"; dayFilter: string }> = [
+      {
+        window: "recent",
+        dayFilter: "day >= today() - INTERVAL 7 DAY",
+      },
+      {
+        window: "prior",
+        dayFilter:
+          "day BETWEEN today() - INTERVAL 14 DAY AND today() - INTERVAL 8 DAY",
+      },
+    ];
+
+    const out: Array<MetricDriftWindowRow> = [];
+
+    for (const windowSpec of windows) {
+      const sql: string = `
+        SELECT
+          name,
+          primaryEntityId,
+          avgMerge(meanState)          AS mean,
+          countMerge(sampleCountState) AS sampleCount
+        FROM MetricBaselineHourly
+        WHERE projectId = '${projectIdStr}'
+          AND ${windowSpec.dayFilter}
+        GROUP BY name, primaryEntityId
+        ORDER BY sampleCount DESC
+        LIMIT ${limit}
+      `;
+
+      const resultSet: {
+        json: () => Promise<{
+          data: Array<{
+            name: string;
+            primaryEntityId: string;
+            mean: number | string;
+            sampleCount: number | string;
+          }>;
+        }>;
+      } = (await this.executeQuery(sql)) as unknown as {
+        json: () => Promise<{
+          data: Array<{
+            name: string;
+            primaryEntityId: string;
+            mean: number | string;
+            sampleCount: number | string;
+          }>;
+        }>;
+      };
+
+      const parsed: {
+        data: Array<{
+          name: string;
+          primaryEntityId: string;
+          mean: number | string;
+          sampleCount: number | string;
+        }>;
+      } = await resultSet.json();
+
+      for (const row of parsed.data) {
+        out.push({
+          name: String(row.name || ""),
+          primaryEntityId: String(row.primaryEntityId || ""),
+          mean: this.toNumber(row.mean),
+          sampleCount: this.toNumber(row.sampleCount),
+          window: windowSpec.window,
+        });
+      }
+    }
+
+    logger.debug("MetricBaselineService.getWeekOverWeekDrift", {
+      projectId: projectIdStr,
+      rowCount: out.length,
+    } as LogAttributes);
+
+    return out;
+  }
+
   /**
    * Build a series of (time, mean, expectedHigh, expectedLow) points
    * spanning [startTime, endTime] in `intervalMinutes` steps. Each

package/Server/Services/MonitorService.ts

@@ -148,6 +148,21 @@ export class Service extends DatabaseService<Model> {
           monitorDestination =
             firstStep.data.externalStatusPageMonitor.statusPageUrl || "";
         }
+
+        // For SQL monitors, show host:port/database (never the credentials).
+        if (
+          monitorType === MonitorType.SQLQuery &&
+          firstStep?.data?.sqlMonitor
+        ) {
+          const sql: {
+            host: string;
+            port: number;
+            databaseName: string;
+          } = firstStep.data.sqlMonitor;
+          if (sql.host) {
+            monitorDestination = `${sql.host}:${sql.port}/${sql.databaseName}`;
+          }
+        }
       }
     }