@oneuptime/common 14.0.9 → 14.0.11

package/Server/Services/MetricRecordingRuleService.ts

@@ -1,10 +1,57 @@
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/MetricRecordingRule";
+import CreateBy from "../Types/Database/CreateBy";
+import UpdateBy from "../Types/Database/UpdateBy";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import BadDataException from "../../Types/Exception/BadDataException";
+import SessionReplayBudgetMetricTypeUtil, {
+  SESSION_REPLAY_METRIC_NAME_PREFIX,
+} from "../../Utils/SessionReplay/SessionReplayBudgetMetricType";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  /*
+   * A recording rule writes its output straight into the metric store, past
+   * OTLP ingest, so the reserved session replay names have to be refused
+   * here too: those series open budget incidents and are left out of
+   * telemetry billing by name, so nothing but the budget sweep may write
+   * them (see SessionReplayBudgetMetricTypeUtil.isReservedMetricName).
+   */
+  public static assertOutputMetricNameAllowed(name: unknown): void {
+    if (
+      typeof name === "string" &&
+      SessionReplayBudgetMetricTypeUtil.isReservedMetricName(name.trim())
+    ) {
+      throw new BadDataException(
+        `Metric names that start with "${SESSION_REPLAY_METRIC_NAME_PREFIX}" are reserved for OneUptime's session replay budget metrics. Choose another output metric name.`,
+      );
+    }
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    Service.assertOutputMetricNameAllowed(createBy.data.outputMetricName);
+
+    return { createBy, carryForward: null };
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    // Only an update that sets the name can make it reserved.
+    Service.assertOutputMetricNameAllowed(
+      (updateBy.data as unknown as Record<string, unknown>)["outputMetricName"],
+    );
+
+    return { updateBy, carryForward: null };
+  }
 }
 
 export default new Service();

package/Server/Services/OpenTelemetryIngestService.ts

@@ -44,6 +44,8 @@ import ServerlessFunctionService from "./ServerlessFunctionService";
 import CloudResourceService from "./CloudResourceService";
 import RumApplicationService from "./RumApplicationService";
 import IoTFleetService from "./IoTFleetService";
+import EnterpriseEdition from "../Enterprise/EnterpriseEdition";
+import EnterpriseFeature from "../Enterprise/EnterpriseFeature";
 import GlobalCache from "../Infrastructure/GlobalCache";
 import InProcessMemo from "../Utils/InProcessMemo";
 import ColumnLength from "../../Types/Database/ColumnLength";
@@ -472,6 +474,37 @@ export default class OTelIngestService {
     return context;
   }
 
+  /*
+   * Retention overrides - retention by telemetry type (project-wide and per
+   * service or resource) and per-service or per-resource retention - are an
+   * Enterprise feature (EnterpriseFeature.TelemetryRetention). While it is
+   * not active (the Community Edition, or a self-hosted license that lapsed
+   * or leaves it out) every row gets the project's default retention, and the
+   * configured overrides are kept, unused, until it is active again.
+   *
+   * Asked each time metadata is built, not when the caches above are warmed,
+   * so a license change takes effect on the next row without waiting for a
+   * cache to expire. Every signal resolves its retention from this metadata
+   * (resolveTelemetryRetentionInDays), so this is the one place to decide.
+   */
+  public static applyRetentionOverrideEdition(
+    metadata: TelemetryServiceMetadata,
+  ): TelemetryServiceMetadata {
+    if (
+      EnterpriseEdition.isFeatureActive(EnterpriseFeature.TelemetryRetention)
+    ) {
+      return metadata;
+    }
+
+    return {
+      ...metadata,
+      dataRententionInDays: metadata.projectRetentionInDays,
+      serviceRetentionConfig: null,
+      serviceRetentionInDays: null,
+      projectRetentionConfig: null,
+    };
+  }
+
   @CaptureSpan()
   public static async telemetryServiceFromName(data: {
     serviceName: string;
@@ -746,7 +779,7 @@ export default class OTelIngestService {
     ): TelemetryServiceMetadata => {
       const serviceLevelRetention: number | null =
         resolved.retainTelemetryDataForDays ?? null;
-      return {
+      return this.applyRetentionOverrideEdition({
         serviceName: data.serviceName,
         primaryEntityId: new ObjectID(resolved.serviceId),
         primaryEntityType: ServiceType.OpenTelemetry,
@@ -766,7 +799,7 @@ export default class OTelIngestService {
         serviceRetentionInDays: serviceLevelRetention,
         projectRetentionConfig: projectContext.projectRetentionConfig,
         projectRetentionInDays: projectContext.projectRetentionInDays,
-      };
+      });
     };
 
     if (!resolution) {
@@ -863,7 +896,7 @@ export default class OTelIngestService {
     const resourceRetention: ResourceRetention =
       await this.getResourceRetention(data.resourceId, data.primaryEntityType);
 
-    return {
+    return this.applyRetentionOverrideEdition({
       serviceName: data.serviceName,
       primaryEntityId: data.resourceId,
       primaryEntityType: data.primaryEntityType,
@@ -874,7 +907,7 @@ export default class OTelIngestService {
       serviceRetentionInDays: resourceRetention.retainTelemetryDataForDays,
       projectRetentionConfig: projectContext.projectRetentionConfig,
       projectRetentionInDays: projectContext.projectRetentionInDays,
-    };
+    });
   }
 
   /*

package/Server/Services/PodmanHostService.ts

@@ -3,7 +3,15 @@ import PodmanHostLabelRuleEngineService from "./PodmanHostLabelRuleEngineService
 import PodmanHostOwnerRuleEngineService from "./PodmanHostOwnerRuleEngineService";
 import Model from "../../Models/DatabaseModels/PodmanHost";
 import Label from "../../Models/DatabaseModels/Label";
-import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import { OnCreate, OnDelete, OnUpdate } from "../Types/Database/Hooks";
+import CreateBy from "../Types/Database/CreateBy";
+import DeleteBy from "../Types/Database/DeleteBy";
+import UpdateBy from "../Types/Database/UpdateBy";
+import ResourceAiAccessSettings, {
+  ResourceAiAccessFeedItem,
+} from "../Utils/AI/ResourceAccess/ResourceAiAccessSettings";
+import ResourceAiDeleteCleanup from "../Utils/AI/ResourceAccess/ResourceAiDeleteCleanup";
+import AiResourceType from "../../Types/ResourceAiAgent/AiResourceType";
 import PodmanHostFeedService from "./PodmanHostFeedService";
 import { PodmanHostFeedEventType } from "../../Models/DatabaseModels/PodmanHostFeed";
 import ResourceFeedUtil from "../Utils/ResourceFeed/ResourceFeedUtil";
@@ -472,6 +480,79 @@ export class Service extends DatabaseService<Model> {
     });
   }
 
+  /*
+   * Deleting a Podman host settles its in-flight AI remediation rounds and
+   * removes its resource AI agent — read before the delete, done after it for
+   * the Podman hosts actually deleted (ResourceAiDeleteCleanup, shared by every
+   * resource AI agent's resource).
+   */
+  @CaptureSpan()
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    return {
+      deleteBy,
+      carryForward: await ResourceAiDeleteCleanup.beforeDelete({
+        resourceType: AiResourceType.PodmanHost,
+        service: this,
+        deleteBy,
+      }),
+    };
+  }
+
+  @CaptureSpan()
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<Model>,
+    deletedItemIds: Array<ObjectID>,
+  ): Promise<OnDelete<Model>> {
+    await ResourceAiDeleteCleanup.afterDelete({
+      resourceType: AiResourceType.PodmanHost,
+      onDelete,
+      deletedItemIds,
+    });
+
+    return onDelete;
+  }
+
+  /*
+   * A create is held to the same AI access rules as an update, judged
+   * against the never-configured defaults a new Podman host starts from: an
+   * unusable mode or allowlist is refused for every caller, and the
+   * server-only aiAccess* columns for every caller but root (a master admin
+   * included, whom the create column ACLs never check).
+   */
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    ResourceAiAccessSettings.checkCreate({
+      resourceType: AiResourceType.PodmanHost,
+      createBy,
+    });
+
+    return { createBy, carryForward: null };
+  }
+
+  /*
+   * An operator's write of an AI access setting (the investigation switch, the
+   * remediation mode, the command allowlist) is validated and checked against
+   * who may make AI do more on this Podman host — the rules every resource AI
+   * agent's resource shares (ResourceAiAccessSettings).
+   */
+  @CaptureSpan()
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    return {
+      updateBy,
+      carryForward: await ResourceAiAccessSettings.checkUpdate({
+        resourceType: AiResourceType.PodmanHost,
+        service: this,
+        updateBy,
+      }),
+    };
+  }
+
   @CaptureSpan()
   protected override async onUpdateSuccess(
     onUpdate: OnUpdate<Model>,
@@ -483,6 +564,33 @@ export class Service extends DatabaseService<Model> {
       },
     );
 
+    /*
+     * An operator's AI access write: recorded on the feed, and the Podman host
+     * marked AI-configured.
+     */
+    await ResourceAiAccessSettings.afterUpdate({
+      service: this,
+      onUpdate,
+      updatedItemIds,
+      getResourceMarkdownLink: (
+        projectId: ObjectID,
+        podmanHostId: ObjectID,
+      ): Promise<string> => {
+        return this.getPodmanHostMarkdownLink(projectId, podmanHostId);
+      },
+      createFeedItem: async (item: ResourceAiAccessFeedItem): Promise<void> => {
+        await PodmanHostFeedService.createPodmanHostFeedItem({
+          podmanHostId: item.resourceId,
+          projectId: item.projectId,
+          podmanHostFeedEventType: PodmanHostFeedEventType.PodmanHostUpdated,
+          displayColor: item.displayColor,
+          feedInfoInMarkdown: item.feedInfoInMarkdown,
+          moreInformationInMarkdown: item.moreInformationInMarkdown,
+          userId: item.userId,
+        });
+      },
+    });
+
     return onUpdate;
   }
 

package/Server/Services/ProjectService.ts

@@ -14,7 +14,6 @@ import { OnCreate, OnDelete, OnFind, OnUpdate } from "../Types/Database/Hooks";
 import QueryHelper from "../Types/Database/QueryHelper";
 import UpdateBy from "../Types/Database/UpdateBy";
 import logger, { LogAttributes } from "../Utils/Logger";
-import EditionEnforcement from "../Utils/EditionEnforcement";
 import EnterpriseEdition from "../Enterprise/EnterpriseEdition";
 import EnterpriseFeature from "../Enterprise/EnterpriseFeature";
 import Errors from "../Utils/Errors";
@@ -145,15 +144,6 @@ export type ProjectBalanceColumnName =
  */
 export const MAX_BALANCE_ADJUSTMENT_IN_USD_CENTS: number = 10_000 * 100;
 
-/*
- * The project columns that hold its SSO requirement: the ones onFindSuccess
- * masks and onBeforeUpdate guards while SSO is not active.
- */
-export const PROJECT_SSO_REQUIREMENT_COLUMNS: ReadonlyArray<string> = [
-  "requireSsoForLogin",
-  "requireSsoWithSsoProviderId",
-];
-
 // The project columns that decide what the audit log records and keeps.
 export interface ProjectAuditLogSettings {
   enableAuditLogs: boolean;
@@ -693,17 +683,6 @@ export class ProjectService extends DatabaseService<Model> {
   protected override async onBeforeUpdate(
     updateBy: UpdateBy<Model>,
   ): Promise<OnUpdate<Model>> {
-    /*
-     * While SSO is not active this caller only ever read the requirement as
-     * off (see onFindSuccess), so a write of it must not switch the stored
-     * requirement off, or set one nobody could see. Drops or refuses it.
-     */
-    EditionEnforcement.guardSsoRequirementWrite({
-      props: updateBy.props,
-      data: updateBy.data as unknown as Record<string, unknown>,
-      columns: PROJECT_SSO_REQUIREMENT_COLUMNS,
-    });
-
     /*
      * Any project field could have changed; invalidate the in-process cache
      * of the SSO flag. Cheap to refetch on the next request.
@@ -2857,44 +2836,6 @@ These are no longer recorded against the project and have to be cancelled by han
     return { findBy, carryForward: null };
   }
 
-  /*
-   * While SSO is not active a project's SSO requirement is not enforced: on
-   * the Community Edition (the SSO login routes are part of the Enterprise
-   * Edition), and on an Enterprise install whose license is lapsed or does
-   * not include SSO (the routes refuse). Reads made for a caller then report
-   * the EFFECTIVE value: not required, no required provider. Clients decide
-   * from these columns whether to start an SSO flow - the mobile app hides a
-   * project's on-call data behind an SSO login it cannot complete, and its
-   * store builds cannot be patched.
-   *
-   * Only the returned objects change. Internal (root) reads, and the stored
-   * row, keep the real value, and onBeforeUpdate keeps a caller from writing
-   * the masked value back. So running the Enterprise Edition with a valid
-   * license (or in its trial or grace period) again restores enforcement
-   * exactly as configured.
-   */
-  @CaptureSpan()
-  protected override async onFindSuccess(
-    onFind: OnFind<Model>,
-    items: Array<Model>,
-  ): Promise<OnFind<Model>> {
-    if (
-      EditionEnforcement.shouldMaskSsoRequirementOnRead(onFind.findBy.props)
-    ) {
-      for (const item of items) {
-        if (item.requireSsoForLogin !== undefined) {
-          item.requireSsoForLogin = false;
-        }
-
-        if (item.requireSsoWithSsoProviderId !== undefined) {
-          item.requireSsoWithSsoProviderId = null!;
-        }
-      }
-    }
-
-    return { ...onFind, carryForward: items };
-  }
-
   @CaptureSpan()
   protected override async onBeforeDelete(
     deleteBy: DeleteBy<Model>,

package/Server/Services/ProxmoxClusterService.ts

@@ -3,7 +3,15 @@ import ProxmoxClusterLabelRuleEngineService from "./ProxmoxClusterLabelRuleEngin
 import ProxmoxClusterOwnerRuleEngineService from "./ProxmoxClusterOwnerRuleEngineService";
 import Model from "../../Models/DatabaseModels/ProxmoxCluster";
 import Label from "../../Models/DatabaseModels/Label";
-import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import { OnCreate, OnDelete, OnUpdate } from "../Types/Database/Hooks";
+import CreateBy from "../Types/Database/CreateBy";
+import DeleteBy from "../Types/Database/DeleteBy";
+import UpdateBy from "../Types/Database/UpdateBy";
+import ResourceAiAccessSettings, {
+  ResourceAiAccessFeedItem,
+} from "../Utils/AI/ResourceAccess/ResourceAiAccessSettings";
+import ResourceAiDeleteCleanup from "../Utils/AI/ResourceAccess/ResourceAiDeleteCleanup";
+import AiResourceType from "../../Types/ResourceAiAgent/AiResourceType";
 import ProxmoxClusterFeedService from "./ProxmoxClusterFeedService";
 import { ProxmoxClusterFeedEventType } from "../../Models/DatabaseModels/ProxmoxClusterFeed";
 import ResourceFeedUtil from "../Utils/ResourceFeed/ResourceFeedUtil";
@@ -485,6 +493,79 @@ export class Service extends DatabaseService<Model> {
     });
   }
 
+  /*
+   * Deleting a Proxmox cluster settles its in-flight AI remediation rounds and
+   * removes its resource AI agent — read before the delete, done after it for
+   * the Proxmox clusters actually deleted (ResourceAiDeleteCleanup, shared by
+   * every resource AI agent's resource).
+   */
+  @CaptureSpan()
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    return {
+      deleteBy,
+      carryForward: await ResourceAiDeleteCleanup.beforeDelete({
+        resourceType: AiResourceType.ProxmoxCluster,
+        service: this,
+        deleteBy,
+      }),
+    };
+  }
+
+  @CaptureSpan()
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<Model>,
+    deletedItemIds: Array<ObjectID>,
+  ): Promise<OnDelete<Model>> {
+    await ResourceAiDeleteCleanup.afterDelete({
+      resourceType: AiResourceType.ProxmoxCluster,
+      onDelete,
+      deletedItemIds,
+    });
+
+    return onDelete;
+  }
+
+  /*
+   * A create is held to the same AI access rules as an update, judged
+   * against the never-configured defaults a new Proxmox cluster starts from: an
+   * unusable mode or allowlist is refused for every caller, and the
+   * server-only aiAccess* columns for every caller but root (a master admin
+   * included, whom the create column ACLs never check).
+   */
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    ResourceAiAccessSettings.checkCreate({
+      resourceType: AiResourceType.ProxmoxCluster,
+      createBy,
+    });
+
+    return { createBy, carryForward: null };
+  }
+
+  /*
+   * An operator's write of an AI access setting (the investigation switch, the
+   * remediation mode, the command allowlist) is validated and checked against
+   * who may make AI do more on this Proxmox cluster — the rules every resource
+   * AI agent's resource shares (ResourceAiAccessSettings).
+   */
+  @CaptureSpan()
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    return {
+      updateBy,
+      carryForward: await ResourceAiAccessSettings.checkUpdate({
+        resourceType: AiResourceType.ProxmoxCluster,
+        service: this,
+        updateBy,
+      }),
+    };
+  }
+
   @CaptureSpan()
   protected override async onUpdateSuccess(
     onUpdate: OnUpdate<Model>,
@@ -496,6 +577,34 @@ export class Service extends DatabaseService<Model> {
       },
     );
 
+    /*
+     * An operator's AI access write: recorded on the feed, and the Proxmox
+     * cluster marked AI-configured.
+     */
+    await ResourceAiAccessSettings.afterUpdate({
+      service: this,
+      onUpdate,
+      updatedItemIds,
+      getResourceMarkdownLink: (
+        projectId: ObjectID,
+        proxmoxClusterId: ObjectID,
+      ): Promise<string> => {
+        return this.getProxmoxClusterMarkdownLink(projectId, proxmoxClusterId);
+      },
+      createFeedItem: async (item: ResourceAiAccessFeedItem): Promise<void> => {
+        await ProxmoxClusterFeedService.createProxmoxClusterFeedItem({
+          proxmoxClusterId: item.resourceId,
+          projectId: item.projectId,
+          proxmoxClusterFeedEventType:
+            ProxmoxClusterFeedEventType.ProxmoxClusterUpdated,
+          displayColor: item.displayColor,
+          feedInfoInMarkdown: item.feedInfoInMarkdown,
+          moreInformationInMarkdown: item.moreInformationInMarkdown,
+          userId: item.userId,
+        });
+      },
+    });
+
     return onUpdate;
   }