@oneuptime/common 12.0.14 → 12.0.16

package/Server/Services/Index.ts

@@ -76,6 +76,7 @@ import LlmProviderService from "./LlmProviderService";
 import DataSourceService from "./DataSourceService";
 import AuditLogService from "./AuditLogService";
 import LogService from "./LogService";
+import SecurityEventService from "./SecurityEventService";
 import MailService from "./MailService";
 import MetricService from "./MetricService";
 import MetricItemAggMV1mService from "./MetricItemAggMV1mService";
@@ -85,6 +86,8 @@ import MetricItemAggMV1mByK8sClusterService from "./MetricItemAggMV1mByK8sCluste
 import MetricItemAggMV1mByContainerService from "./MetricItemAggMV1mByContainerService";
 import MutableMetricService from "./MutableMetricService";
 import MetricBaselineService from "./MetricBaselineService";
+import SpanCountBaselineService from "./SpanCountBaselineService";
+import LogCountBaselineService from "./LogCountBaselineService";
 import MonitorCustomFieldService from "./MonitorCustomFieldService";
 import MonitorGroupOwnerTeamService from "./MonitorGroupOwnerTeamService";
 import MonitorGroupOwnerUserService from "./MonitorGroupOwnerUserService";
@@ -234,6 +237,8 @@ import AlertInternalNoteService from "./AlertInternalNoteService";
 import AlertOwnerTeamService from "./AlertOwnerTeamService";
 import AlertOwnerUserService from "./AlertOwnerUserService";
 import AlertSeverityService from "./AlertSeverityService";
+import DetectionRuleService from "./DetectionRuleService";
+import GoogleSecOpsConnectionService from "./GoogleSecOpsConnectionService";
 import AlertNoteTemplateService from "./AlertNoteTemplateService";
 
 // AlertEpisode Services
@@ -257,9 +262,17 @@ import IncidentEpisodeStateTimelineService from "./IncidentEpisodeStateTimelineS
 import IncidentEpisodePublicNoteService from "./IncidentEpisodePublicNoteService";
 import AlertGroupingRuleService from "./AlertGroupingRuleService";
 import IncidentSlaRuleService from "./IncidentSlaRuleService";
+import IncidentMeasurementService from "./IncidentMeasurementService";
+import IncidentMeasurementValueService from "./IncidentMeasurementValueService";
+import AlertMeasurementService from "./AlertMeasurementService";
+import AlertMeasurementValueService from "./AlertMeasurementValueService";
+import ScheduledMaintenanceMeasurementService from "./ScheduledMaintenanceMeasurementService";
+import ScheduledMaintenanceMeasurementValueService from "./ScheduledMaintenanceMeasurementValueService";
 import IncidentSlaService from "./IncidentSlaService";
 import ServiceLevelObjectiveService from "./ServiceLevelObjectiveService";
 import ServiceLevelObjectiveBurnRateRuleService from "./ServiceLevelObjectiveBurnRateRuleService";
+import LlmCostBudgetService from "./LlmCostBudgetService";
+import LlmModelPriceService from "./LlmModelPriceService";
 import ServiceLevelObjectiveOwnerUserService from "./ServiceLevelObjectiveOwnerUserService";
 import ServiceLevelObjectiveOwnerTeamService from "./ServiceLevelObjectiveOwnerTeamService";
 import SloHistoryService from "./SloHistoryService";
@@ -522,6 +535,8 @@ const services: Array<BaseService> = [
   AlertOwnerTeamService,
   AlertOwnerUserService,
   AlertSeverityService,
+  DetectionRuleService,
+  GoogleSecOpsConnectionService,
   AlertNoteTemplateService,
   AlertFeedService,
 
@@ -546,9 +561,17 @@ const services: Array<BaseService> = [
   IncidentEpisodePublicNoteService,
   AlertGroupingRuleService,
   IncidentSlaRuleService,
+  IncidentMeasurementService,
+  IncidentMeasurementValueService,
+  AlertMeasurementService,
+  AlertMeasurementValueService,
+  ScheduledMaintenanceMeasurementService,
+  ScheduledMaintenanceMeasurementValueService,
   IncidentSlaService,
   ServiceLevelObjectiveService,
   ServiceLevelObjectiveBurnRateRuleService,
+  LlmCostBudgetService,
+  LlmModelPriceService,
   ServiceLevelObjectiveOwnerUserService,
   ServiceLevelObjectiveOwnerTeamService,
   IncidentReminderRuleService,
@@ -593,6 +616,12 @@ export const AnalyticsServices: Array<
   MetricItemAggMV1mByK8sClusterService,
   MetricItemAggMV1mByContainerService,
   MetricBaselineService,
+  /*
+   * Span/log volume baselines for the count anomaly criteria. Same MV
+   * target pattern as MetricBaselineService.
+   */
+  SpanCountBaselineService,
+  LogCountBaselineService,
   ExceptionInstanceService,
   KubernetesCostAllocationService,
   MonitorLogService,
@@ -607,6 +636,7 @@ export const AnalyticsServices: Array<
   RumSessionService,
   RumSessionChunkService,
   AuditLogService,
+  SecurityEventService,
 ];
 
 export default services;

package/Server/Services/LlmCostBudgetService.ts

@@ -0,0 +1,93 @@
+import Model from "../../Models/DatabaseModels/LlmCostBudget";
+import BadDataException from "../../Types/Exception/BadDataException";
+import CreateBy from "../Types/Database/CreateBy";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import UpdateBy from "../Types/Database/UpdateBy";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import DatabaseService from "./DatabaseService";
+
+const BUDGET_ERROR_MESSAGE: string =
+  "Daily budget must be a number greater than 0.";
+
+/*
+ * Budgets do not fire alerts themselves: the evaluation worker publishes each
+ * budget's spend and percent-used as oneuptime.llm.budget.* metrics, and
+ * Metrics monitors own the alerting (thresholds, anomaly baselines, on-call
+ * routing). This service only guards the budget definition itself.
+ */
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    /*
+     * Numeric columns can arrive as strings: the dashboard's number fields
+     * hand Formik `e.target.value`, ModelForm copies it verbatim and
+     * BaseModel.fromJSON does not coerce Number/Decimal columns. Coerce,
+     * validate, then write the number back onto the payload so Postgres never
+     * sees a string either. Same convention as
+     * ServiceLevelObjectiveBurnRateRuleService.
+     */
+    createBy.data.dailyBudgetInUSD = this.validateDailyBudget(
+      createBy.data.dailyBudgetInUSD,
+    );
+
+    return {
+      createBy,
+      carryForward: null,
+    };
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    // Same string-arrival path as onBeforeCreate: coerce, validate, write back.
+    const newBudget: unknown = updateBy.data.dailyBudgetInUSD as unknown;
+
+    if (newBudget !== undefined && newBudget !== null) {
+      updateBy.data.dailyBudgetInUSD = this.validateDailyBudget(newBudget);
+    }
+
+    return {
+      updateBy,
+      carryForward: null,
+    };
+  }
+
+  /*
+   * Coerce an API-supplied numeric column to a number. HTML number inputs hand
+   * Formik strings and neither ModelForm nor BaseModel.fromJSON coerces
+   * Number/Decimal columns, so "100" reaches these hooks as a string — and
+   * string comparison is lexicographic. Anything that is not a finite numeric
+   * string or number becomes NaN, which the caller below rejects.
+   */
+  private normalizeNumericInput(value: unknown): number {
+    if (typeof value === "string") {
+      const trimmed: string = value.trim();
+      return trimmed === "" ? Number.NaN : Number(trimmed);
+    }
+
+    if (typeof value === "number") {
+      return value;
+    }
+
+    return Number.NaN;
+  }
+
+  private validateDailyBudget(value: unknown): number {
+    const dailyBudgetInUSD: number = this.normalizeNumericInput(value);
+
+    if (!Number.isFinite(dailyBudgetInUSD) || dailyBudgetInUSD <= 0) {
+      throw new BadDataException(BUDGET_ERROR_MESSAGE);
+    }
+
+    return dailyBudgetInUSD;
+  }
+}
+
+export default new Service();

package/Server/Services/LlmModelPriceService.ts

@@ -0,0 +1,202 @@
+import Model from "../../Models/DatabaseModels/LlmModelPrice";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import CreateBy from "../Types/Database/CreateBy";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import UpdateBy from "../Types/Database/UpdateBy";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import DatabaseService from "./DatabaseService";
+
+const MODEL_PREFIX_ERROR_MESSAGE: string =
+  "Model prefix is required and cannot be empty.";
+const PRICE_ERROR_MESSAGE: string =
+  "must be a number greater than or equal to 0.";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    /*
+     * Numeric columns can arrive as strings: the dashboard's number fields
+     * hand Formik `e.target.value`, ModelForm copies it verbatim and
+     * BaseModel.fromJSON does not coerce Number/Decimal columns. Coerce,
+     * validate, then write the number back onto the payload so Postgres never
+     * sees a string either. Same convention as LlmCostBudgetService.
+     */
+    createBy.data.modelPrefix = this.validateModelPrefix(
+      createBy.data.modelPrefix,
+    );
+
+    createBy.data.inputPricePerMillionTokensInUSD = this.validatePrice(
+      createBy.data.inputPricePerMillionTokensInUSD,
+      "Input price",
+    );
+
+    createBy.data.outputPricePerMillionTokensInUSD = this.validatePrice(
+      createBy.data.outputPricePerMillionTokensInUSD,
+      "Output price",
+    );
+
+    if (createBy.data.projectId) {
+      await this.throwIfDuplicatePrefix({
+        projectId: createBy.data.projectId,
+        modelPrefix: createBy.data.modelPrefix,
+      });
+    }
+
+    return {
+      createBy,
+      carryForward: null,
+    };
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    // Same string-arrival path as onBeforeCreate: coerce, validate, write back.
+    const newPrefix: unknown = updateBy.data.modelPrefix as unknown;
+
+    /*
+     * The validated prefix is held in a string-typed local because the
+     * model's update-data field type is `string | (() => string)` (it
+     * allows the deferred function form), so reading it back below would
+     * otherwise not narrow to the plain string throwIfDuplicatePrefix wants.
+     */
+    let validatedPrefix: string | undefined = undefined;
+
+    if (newPrefix !== undefined && newPrefix !== null) {
+      validatedPrefix = this.validateModelPrefix(newPrefix);
+      updateBy.data.modelPrefix = validatedPrefix;
+    }
+
+    const newInputPrice: unknown = updateBy.data
+      .inputPricePerMillionTokensInUSD as unknown;
+
+    if (newInputPrice !== undefined && newInputPrice !== null) {
+      updateBy.data.inputPricePerMillionTokensInUSD = this.validatePrice(
+        newInputPrice,
+        "Input price",
+      );
+    }
+
+    const newOutputPrice: unknown = updateBy.data
+      .outputPricePerMillionTokensInUSD as unknown;
+
+    if (newOutputPrice !== undefined && newOutputPrice !== null) {
+      updateBy.data.outputPricePerMillionTokensInUSD = this.validatePrice(
+        newOutputPrice,
+        "Output price",
+      );
+    }
+
+    // Renaming a prefix must not collide with another entry of the project.
+    if (validatedPrefix) {
+      const itemsToUpdate: Array<Model> = await this.findBy({
+        query: updateBy.query,
+        skip: 0,
+        limit: LIMIT_PER_PROJECT,
+        select: {
+          _id: true,
+          projectId: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      for (const item of itemsToUpdate) {
+        if (!item.projectId) {
+          continue;
+        }
+
+        await this.throwIfDuplicatePrefix({
+          projectId: item.projectId,
+          modelPrefix: validatedPrefix,
+          excludeId: item.id || undefined,
+        });
+      }
+    }
+
+    return {
+      updateBy,
+      carryForward: null,
+    };
+  }
+
+  /*
+   * Two entries with the same prefix would make the ingest-time price lookup
+   * ambiguous (first-loaded wins), so reject the duplicate at write time
+   * instead of silently pricing with one of them.
+   */
+  private async throwIfDuplicatePrefix(data: {
+    projectId: ObjectID;
+    modelPrefix: string;
+    excludeId?: ObjectID | undefined;
+  }): Promise<void> {
+    const existing: Model | null = await this.findOneBy({
+      query: {
+        projectId: data.projectId,
+        modelPrefix: data.modelPrefix,
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!existing) {
+      return;
+    }
+
+    if (
+      data.excludeId &&
+      existing.id?.toString() === data.excludeId.toString()
+    ) {
+      return;
+    }
+
+    throw new BadDataException(
+      `A price for the model prefix "${data.modelPrefix}" already exists in this project.`,
+    );
+  }
+
+  /*
+   * Prefixes are matched lowercase against normalized model names
+   * (LlmCostCatalogUtil), so store them lowercase — otherwise an entry saved
+   * as "GPT-4o" would never match anything.
+   */
+  private validateModelPrefix(value: unknown): string {
+    if (typeof value !== "string" || value.trim().length === 0) {
+      throw new BadDataException(MODEL_PREFIX_ERROR_MESSAGE);
+    }
+
+    return value.trim().toLowerCase();
+  }
+
+  private validatePrice(value: unknown, label: string): number {
+    let price: number | null = null;
+
+    if (typeof value === "number") {
+      price = value;
+    } else if (typeof value === "string" && value.trim() !== "") {
+      price = Number(value);
+    }
+
+    if (price === null || !isFinite(price) || price < 0) {
+      throw new BadDataException(`${label} ${PRICE_ERROR_MESSAGE}`);
+    }
+
+    return price;
+  }
+}
+
+export default new Service();