@oneuptime/common 10.2.0 → 10.2.2

package/Server/API/ProjectOIDC.ts

@@ -0,0 +1,73 @@
+import ProjectOidcService, {
+  Service as ProjectOidcServiceType,
+} from "../Services/ProjectOidcService";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  NextFunction,
+} from "../Utils/Express";
+import Response from "../Utils/Response";
+import BaseAPI from "./BaseAPI";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import PositiveNumber from "../../Types/PositiveNumber";
+import ProjectOIDC from "../../Models/DatabaseModels/ProjectOidc";
+
+export default class ProjectOidcAPI extends BaseAPI<
+  ProjectOIDC,
+  ProjectOidcServiceType
+> {
+  public constructor() {
+    super(ProjectOIDC, ProjectOidcService);
+
+    // OIDC Fetch API
+    this.router.post(
+      `${new this.entityType()
+        .getCrudApiPath()
+        ?.toString()}/:projectId/oidc-list`,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const projectId: ObjectID = new ObjectID(
+            req.params["projectId"] as string,
+          );
+
+          if (!projectId) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("Invalid project id."),
+            );
+          }
+
+          const oidc: Array<ProjectOIDC> = await this.service.findBy({
+            query: {
+              projectId: projectId,
+              isEnabled: true,
+            },
+            limit: LIMIT_PER_PROJECT,
+            skip: 0,
+            select: {
+              name: true,
+              description: true,
+              _id: true,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+
+          return Response.sendEntityArrayResponse(
+            req,
+            res,
+            oidc,
+            new PositiveNumber(oidc.length),
+            ProjectOIDC,
+          );
+        } catch (err) {
+          return next(err);
+        }
+      },
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1778506655291-AddProjectOIDC.ts

@@ -0,0 +1,79 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddProjectOIDC1778506655291 implements MigrationInterface {
+  name = "AddProjectOIDC1778506655291";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "ProjectOIDC" ("_id" uuid NOT NULL DEFAULT uuid_generate_v4(), "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "deletedAt" TIMESTAMP WITH TIME ZONE, "version" integer NOT NULL, "projectId" uuid NOT NULL, "name" character varying(100) NOT NULL, "description" character varying NOT NULL, "discoveryURL" text NOT NULL, "issuerURL" text NOT NULL, "clientId" character varying(100) NOT NULL, "clientSecret" character varying NOT NULL, "scopes" character varying(100) NOT NULL, "emailClaimName" character varying(100) NOT NULL, "nameClaimName" character varying(100) NOT NULL, "createdByUserId" uuid, "deletedByUserId" uuid, "isEnabled" boolean NOT NULL DEFAULT false, "isTested" boolean NOT NULL DEFAULT false, CONSTRAINT "PK_22abf8119bac3f7f4f9f03b201f" PRIMARY KEY ("_id"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_b5b93c3e2885549c370b816194" ON "ProjectOIDC" ("projectId") `,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "ProjectOidcTeam" ("projectOidcId" uuid NOT NULL, "teamId" uuid NOT NULL, CONSTRAINT "PK_bdae022f28d23653e2aa4a40abb" PRIMARY KEY ("projectOidcId", "teamId"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_8c317a3effac6698ad8dfbc82d" ON "ProjectOidcTeam" ("projectOidcId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_456cebe2924528d694b29f91bc" ON "ProjectOidcTeam" ("teamId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type":"Recurring","value":{"intervalType":"Day","intervalCount":{"_type":"PositiveNumber","value":1}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type":"RestrictionTimes","value":{"restictionType":"None","dayRestrictionTimes":null,"weeklyRestrictionTimes":[]}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectOIDC" ADD CONSTRAINT "FK_b5b93c3e2885549c370b8161940" FOREIGN KEY ("projectId") REFERENCES "Project"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectOIDC" ADD CONSTRAINT "FK_df47207e1005bef42ca062f7a4b" FOREIGN KEY ("createdByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectOIDC" ADD CONSTRAINT "FK_3f386ff54e38e36f4c016187648" FOREIGN KEY ("deletedByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectOidcTeam" ADD CONSTRAINT "FK_8c317a3effac6698ad8dfbc82d4" FOREIGN KEY ("projectOidcId") REFERENCES "ProjectOIDC"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectOidcTeam" ADD CONSTRAINT "FK_456cebe2924528d694b29f91bc9" FOREIGN KEY ("teamId") REFERENCES "Team"("_id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "ProjectOidcTeam" DROP CONSTRAINT "FK_456cebe2924528d694b29f91bc9"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectOidcTeam" DROP CONSTRAINT "FK_8c317a3effac6698ad8dfbc82d4"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectOIDC" DROP CONSTRAINT "FK_3f386ff54e38e36f4c016187648"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectOIDC" DROP CONSTRAINT "FK_df47207e1005bef42ca062f7a4b"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ProjectOIDC" DROP CONSTRAINT "FK_b5b93c3e2885549c370b8161940"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type": "RestrictionTimes", "value": {"restictionType": "None", "dayRestrictionTimes": null, "weeklyRestrictionTimes": []}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type": "Recurring", "value": {"intervalType": "Day", "intervalCount": {"_type": "PositiveNumber", "value": 1}}}'`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_456cebe2924528d694b29f91bc"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_8c317a3effac6698ad8dfbc82d"`,
+    );
+    await queryRunner.query(`DROP TABLE "ProjectOidcTeam"`);
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_b5b93c3e2885549c370b816194"`,
+    );
+    await queryRunner.query(`DROP TABLE "ProjectOIDC"`);
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -312,6 +312,7 @@ import { AddOwnerRuleInheritFlags1778413144103 } from "./1778413144103-AddOwnerR
 import { AddAlertIsPrivate1778438949454 } from "./1778438949454-AddAlertIsPrivate";
 import { AddPrivacyRules1778440665575 } from "./1778440665575-AddPrivacyRules";
 import { AddEpisodePrivacyRules1778442385970 } from "./1778442385970-AddEpisodePrivacyRules";
+import { AddProjectOIDC1778506655291 } from "./1778506655291-AddProjectOIDC";
 export default [
   InitialMigration,
   MigrationName1717678334852,
@@ -627,4 +628,5 @@ export default [
   AddAlertIsPrivate1778438949454,
   AddPrivacyRules1778440665575,
   AddEpisodePrivacyRules1778442385970,
+  AddProjectOIDC1778506655291,
 ];

package/Server/Services/AlertLabelRuleEngineService.ts

@@ -127,6 +127,22 @@ class AlertLabelRuleEngineServiceClass {
         .of(alert.id.toString())
         .add(newLabelIds);
 
+      /*
+       * Sync in-memory alert.labels with the now-persisted set so downstream
+       * rule engines (AlertOnCallRuleEngineService) can match on these labels
+       * in the same onCreateSuccess chain. Without this, the on-call engine sees
+       * only the criteria-time labels and skips rules keyed on rule-added labels.
+       */
+      const mergedLabelIds: Set<string> = new Set([
+        ...existingLabelIds,
+        ...newLabelIds,
+      ]);
+      alert.labels = Array.from(mergedLabelIds).map((id: string) => {
+        const label: Label = new Label();
+        label.id = new ObjectID(id);
+        return label;
+      });
+
       logger.debug(
         `AlertLabelRuleEngine attached ${newLabelIds.length} labels to alert ${alert.id}`,
         { projectId: alert.projectId.toString() } as LogAttributes,

package/Server/Services/IncidentLabelRuleEngineService.ts

@@ -163,6 +163,22 @@ class IncidentLabelRuleEngineServiceClass {
         .of(incident.id.toString())
         .add(newLabelIds);
 
+      /*
+       * Sync in-memory incident.labels with the now-persisted set so downstream
+       * rule engines (IncidentOnCallRuleEngineService) can match on these labels
+       * in the same onCreateSuccess chain. Without this, the on-call engine sees
+       * only the criteria-time labels and skips rules keyed on rule-added labels.
+       */
+      const mergedLabelIds: Set<string> = new Set([
+        ...existingLabelIds,
+        ...newLabelIds,
+      ]);
+      incident.labels = Array.from(mergedLabelIds).map((id: string) => {
+        const label: Label = new Label();
+        label.id = new ObjectID(id);
+        return label;
+      });
+
       logger.debug(
         `IncidentLabelRuleEngine attached ${newLabelIds.length} labels to incident ${incident.id}`,
         { projectId: incident.projectId.toString() } as LogAttributes,

package/Server/Services/Index.ts

@@ -85,6 +85,7 @@ import ProfileSampleService from "./ProfileSampleService";
 // Project SMTP Config.
 import ProjectSmtpConfigService from "./ProjectSmtpConfigService";
 import ProjectSsoService from "./ProjectSsoService";
+import ProjectOidcService from "./ProjectOidcService";
 import PromoCodeService from "./PromoCodeService";
 import EnterpriseLicenseService from "./EnterpriseLicenseService";
 import OpenSourceDeploymentService from "./OpenSourceDeploymentService";
@@ -300,6 +301,7 @@ const services: Array<BaseService> = [
   AIAgentTaskLogService,
   AIAgentTaskPullRequestService,
   ProjectSsoService,
+  ProjectOidcService,
 
   ScheduledMaintenanceCustomFieldService,
   ScheduledMaintenanceInternalNoteService,

package/Server/Services/OnCallDutyPolicyScheduleService.ts

@@ -1,12 +1,18 @@
 import DatabaseService from "./DatabaseService";
 import OnCallDutyPolicyScheduleLayerService from "./OnCallDutyPolicyScheduleLayerService";
 import OnCallDutyPolicyScheduleLayerUserService from "./OnCallDutyPolicyScheduleLayerUserService";
+import OnCallDutyPolicyUserOverrideService from "./OnCallDutyPolicyUserOverrideService";
 import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import CalendarEvent from "../../Types/Calendar/CalendarEvent";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import OneUptimeDate from "../../Types/Date";
 import ObjectID from "../../Types/ObjectID";
 import LayerUtil, { LayerProps } from "../../Types/OnCallDutyPolicy/Layer";
+import UserOverrideUtil, {
+  UserOverrideRecord,
+} from "../../Types/OnCallDutyPolicy/UserOverrideUtil";
+import OnCallDutyPolicyUserOverride from "../../Models/DatabaseModels/OnCallDutyPolicyUserOverride";
+import QueryHelper from "../Types/Database/QueryHelper";
 import OnCallDutyPolicyScheduleLayer from "../../Models/DatabaseModels/OnCallDutyPolicyScheduleLayer";
 import OnCallDutyPolicyScheduleLayerUser from "../../Models/DatabaseModels/OnCallDutyPolicyScheduleLayerUser";
 import User from "../../Models/DatabaseModels/User";
@@ -914,9 +920,11 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
     return resultReturn;
   }
 
-  private async getScheduleLayerProps(data: {
-    scheduleId: ObjectID;
-  }): Promise<Array<LayerProps>> {
+  private async getScheduleLayerProps(data: { scheduleId: ObjectID }): Promise<{
+    layerProps: Array<LayerProps>;
+    projectId: ObjectID | null;
+    scheduleUserIds: Array<ObjectID>;
+  }> {
     // get schedule layers.
 
     const scheduleId: ObjectID = data.scheduleId;
@@ -968,23 +976,34 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
       });
 
     const layerProps: Array<LayerProps> = [];
+    const scheduleUserIds: Array<ObjectID> = [];
+    const seenUserIds: Set<string> = new Set<string>();
 
     for (const layer of layers) {
+      const usersForLayer: Array<User> = layerUsers
+        .filter((layerUser: OnCallDutyPolicyScheduleLayerUser) => {
+          return (
+            layerUser.onCallDutyPolicyScheduleLayerId?.toString() ===
+            layer.id?.toString()
+          );
+        })
+        .map((layerUser: OnCallDutyPolicyScheduleLayerUser) => {
+          return layerUser.user!;
+        })
+        .filter((user: User) => {
+          return Boolean(user);
+        });
+
+      for (const user of usersForLayer) {
+        const idStr: string = user.id?.toString() || "";
+        if (idStr && !seenUserIds.has(idStr)) {
+          seenUserIds.add(idStr);
+          scheduleUserIds.push(user.id!);
+        }
+      }
+
       layerProps.push({
-        users:
-          layerUsers
-            .filter((layerUser: OnCallDutyPolicyScheduleLayerUser) => {
-              return (
-                layerUser.onCallDutyPolicyScheduleLayerId?.toString() ===
-                layer.id?.toString()
-              );
-            })
-            .map((layerUser: OnCallDutyPolicyScheduleLayerUser) => {
-              return layerUser.user!;
-            })
-            .filter((user: User) => {
-              return Boolean(user);
-            }) || [],
+        users: usersForLayer,
         startDateTimeOfLayer: layer.startsAt!,
         restrictionTimes: layer.restrictionTimes!,
         rotation: layer.rotation!,
@@ -992,7 +1011,65 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
       });
     }
 
-    return layerProps;
+    const projectId: ObjectID | null = layers[0]?.projectId || null;
+
+    return { layerProps, projectId, scheduleUserIds };
+  }
+
+  private async fetchOverridesForSchedule(data: {
+    projectId: ObjectID;
+    scheduleUserIds: Array<ObjectID>;
+    windowStart: Date;
+    windowEnd: Date;
+  }): Promise<Array<UserOverrideRecord>> {
+    if (data.scheduleUserIds.length === 0) {
+      return [];
+    }
+
+    const overrides: Array<OnCallDutyPolicyUserOverride> =
+      await OnCallDutyPolicyUserOverrideService.findBy({
+        query: {
+          projectId: data.projectId,
+          startsAt: QueryHelper.lessThanEqualTo(data.windowEnd),
+          endsAt: QueryHelper.greaterThanEqualTo(data.windowStart),
+        },
+        select: {
+          startsAt: true,
+          endsAt: true,
+          overrideUserId: true,
+          routeAlertsToUserId: true,
+          onCallDutyPolicyId: true,
+        },
+        sort: {
+          startsAt: SortOrder.Ascending,
+        },
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+
+    const scheduleUserIdSet: Set<string> = new Set<string>(
+      data.scheduleUserIds.map((id: ObjectID) => {
+        return id.toString();
+      }),
+    );
+
+    return overrides
+      .filter((o: OnCallDutyPolicyUserOverride) => {
+        const overrideUserId: string = o.overrideUserId?.toString() || "";
+        return scheduleUserIdSet.has(overrideUserId);
+      })
+      .map((o: OnCallDutyPolicyUserOverride): UserOverrideRecord => {
+        return {
+          overrideUserId: o.overrideUserId?.toString() || "",
+          routeAlertsToUserId: o.routeAlertsToUserId?.toString() || "",
+          startsAt: o.startsAt!,
+          endsAt: o.endsAt!,
+          onCallDutyPolicyId: o.onCallDutyPolicyId?.toString() || null,
+        };
+      });
   }
 
   public async getEventByIndexInSchedule(data: {
@@ -1006,9 +1083,10 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
       } as LogAttributes,
     );
 
-    const layerProps: Array<LayerProps> = await this.getScheduleLayerProps({
-      scheduleId: data.scheduleId,
-    });
+    const { layerProps, projectId, scheduleUserIds } =
+      await this.getScheduleLayerProps({
+        scheduleId: data.scheduleId,
+      });
 
     logger.debug("Layer properties fetched: " + JSON.stringify(layerProps), {
       onCallDutyPolicyScheduleId: data.scheduleId.toString(),
@@ -1042,7 +1120,7 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
       onCallDutyPolicyScheduleId: data.scheduleId.toString(),
     } as LogAttributes);
 
-    const events: Array<CalendarEvent> = this.layerUtil.getMultiLayerEvents(
+    let events: Array<CalendarEvent> = this.layerUtil.getMultiLayerEvents(
       {
         layers: layerProps,
         calendarStartDate: currentStartTime,
@@ -1053,6 +1131,23 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
       },
     );
 
+    if (projectId && events.length > 0) {
+      const overrides: Array<UserOverrideRecord> =
+        await this.fetchOverridesForSchedule({
+          projectId,
+          scheduleUserIds,
+          windowStart: currentStartTime,
+          windowEnd: currentEndTime,
+        });
+
+      if (overrides.length > 0) {
+        events = UserOverrideUtil.applyOverridesToEvents({
+          events,
+          overrides,
+        });
+      }
+    }
+
     logger.debug("Events fetched: " + JSON.stringify(events), {
       onCallDutyPolicyScheduleId: data.scheduleId.toString(),
     } as LogAttributes);
@@ -1064,9 +1159,10 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
   public async getCurrentUserIdInSchedule(
     scheduleId: ObjectID,
   ): Promise<ObjectID | null> {
-    const layerProps: Array<LayerProps> = await this.getScheduleLayerProps({
-      scheduleId: scheduleId,
-    });
+    const { layerProps, projectId, scheduleUserIds } =
+      await this.getScheduleLayerProps({
+        scheduleId: scheduleId,
+      });
 
     if (layerProps.length === 0) {
       return null;
@@ -1078,7 +1174,7 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
       1,
     );
 
-    const events: Array<CalendarEvent> = this.layerUtil.getMultiLayerEvents(
+    let events: Array<CalendarEvent> = this.layerUtil.getMultiLayerEvents(
       {
         layers: layerProps,
         calendarStartDate: currentStartTime,
@@ -1089,6 +1185,23 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
       },
     );
 
+    if (projectId && events.length > 0) {
+      const overrides: Array<UserOverrideRecord> =
+        await this.fetchOverridesForSchedule({
+          projectId,
+          scheduleUserIds,
+          windowStart: currentStartTime,
+          windowEnd: currentEndTime,
+        });
+
+      if (overrides.length > 0) {
+        events = UserOverrideUtil.applyOverridesToEvents({
+          events,
+          overrides,
+        });
+      }
+    }
+
     const currentEvent: CalendarEvent | null = events[0] || null;
 
     if (!currentEvent) {

package/Server/Services/ProjectOidcService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/ProjectOidc";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+
+export default new Service();

package/Server/Utils/Monitor/Criteria/MetricMonitorCriteria.ts

@@ -121,6 +121,9 @@ export default class MetricMonitorCriteria {
       input.monitorStep.data?.metricMonitor?.metricViewConfig?.formulaConfigs ||
       [];
 
+    const nativeUnitsByMetricName: { [key: string]: string } | undefined =
+      metricResponse.nativeUnitsByMetricName;
+
     /*
      * Series-less path: one synthetic "all-series" evaluation over the
      * flat metricResult. Preserves the pre-group-by behavior exactly.
@@ -135,6 +138,7 @@ export default class MetricMonitorCriteria {
           seriesFingerprint: undefined,
           seriesLabels: {},
           projectId: metricResponse.projectId,
+          nativeUnitsByMetricName,
         });
       return [result];
     }
@@ -149,6 +153,7 @@ export default class MetricMonitorCriteria {
           seriesFingerprint: series.fingerprint,
           seriesLabels: series.labels,
           projectId: metricResponse.projectId,
+          nativeUnitsByMetricName,
         });
       }),
     );
@@ -169,6 +174,7 @@ export default class MetricMonitorCriteria {
     seriesFingerprint: string | undefined;
     seriesLabels: JSONObject;
     projectId: { toString(): string } | undefined;
+    nativeUnitsByMetricName?: { [key: string]: string } | undefined;
   }): Promise<MetricSeriesEvaluationResult> {
     const rawThreshold: number | null = CompareCriteria.convertToNumber(
       input.criteriaFilter.value,
@@ -238,6 +244,7 @@ export default class MetricMonitorCriteria {
         criteriaFilter: input.criteriaFilter,
         queryConfigs: input.queryConfigs,
         formulaConfigs: input.formulaConfigs,
+        nativeUnitsByMetricName: input.nativeUnitsByMetricName,
       });
 
     if (input.seriesFingerprint) {
@@ -576,6 +583,7 @@ export default class MetricMonitorCriteria {
     criteriaFilter: CriteriaFilter;
     queryConfigs: Array<MetricQueryConfigData>;
     formulaConfigs: Array<MetricFormulaConfigData>;
+    nativeUnitsByMetricName?: { [key: string]: string } | undefined;
   }): MetricCriteriaContext {
     const q: MetricQueryConfigData | null = input.matchedQuery;
     const f: MetricFormulaConfigData | null = input.matchedFormula;
@@ -587,9 +595,24 @@ export default class MetricMonitorCriteria {
       f?.metricAliasData?.title ||
       "Metric";
 
+    /*
+     * Prefer the legendUnit the user picked, but fall back to the
+     * metric's native unit (loaded from MetricType by the worker). The
+     * fallback matters for ratio metrics like system.filesystem.utilization,
+     * whose native unit is OTel's dimensionless "1" — without it, a "%"
+     * threshold can't be compared against the raw [0, 1] samples.
+     */
+    const rawMetricName: string | undefined =
+      (q?.metricQueryData?.filterData?.metricName as string | undefined) ||
+      undefined;
+    const nativeUnitFromMap: string | undefined = rawMetricName
+      ? input.nativeUnitsByMetricName?.[rawMetricName.toLowerCase()]
+      : undefined;
+
     const unit: string | null =
       (q?.metricAliasData?.legendUnit as string | undefined) ||
       (f?.metricAliasData?.legendUnit as string | undefined) ||
+      nativeUnitFromMap ||
       null;
 
     const aggregationType: MetricsAggregationType | null =

package/Server/Utils/Monitor/MonitorCriteriaObservationBuilder.ts

@@ -23,6 +23,10 @@ import ExceptionMonitorResponse from "../../../Types/Monitor/ExceptionMonitor/Ex
 import MonitorCriteriaMessageFormatter from "./MonitorCriteriaMessageFormatter";
 import MonitorCriteriaDataExtractor from "./MonitorCriteriaDataExtractor";
 import MonitorCriteriaExpectationBuilder from "./MonitorCriteriaExpectationBuilder";
+import MetricMonitorResponse from "../../../Types/Monitor/MetricMonitor/MetricMonitorResponse";
+import MetricQueryConfigData from "../../../Types/Metrics/MetricQueryConfigData";
+import MetricFormulaConfigData from "../../../Types/Metrics/MetricFormulaConfigData";
+import MetricUnitUtil from "../../../Utils/MetricUnitUtil";
 
 export default class MonitorCriteriaObservationBuilder {
   public static describeFilterObservation(input: {
@@ -1127,10 +1131,26 @@ export default class MonitorCriteriaObservationBuilder {
       } returned no data points.`;
     }
 
+    /*
+     * Render the observation in the threshold's unit. The raw samples
+     * arrive in the metric's legendUnit (or its native unit when no
+     * legendUnit was set). If the user picked a different threshold
+     * unit — e.g. "%" against a ratio metric whose native unit is the
+     * dimensionless "1" — convert here so the message reads
+     * "latest 5.85% expected to equal 2" rather than the confusing
+     * "latest 0.0585 expected to equal 2".
+     */
+    const displayValues: Array<number> =
+      MonitorCriteriaObservationBuilder.convertMetricValuesToThresholdUnit({
+        values: metricValues.values,
+        criteriaFilter: input.criteriaFilter,
+        dataToProcess: input.dataToProcess,
+        monitorStep: input.monitorStep,
+        alias: metricValues.alias,
+      });
+
     const summary: string | null =
-      MonitorCriteriaMessageFormatter.summarizeNumericSeries(
-        metricValues.values,
-      );
+      MonitorCriteriaMessageFormatter.summarizeNumericSeries(displayValues);
 
     if (!summary) {
       return null;
@@ -1140,4 +1160,79 @@ export default class MonitorCriteriaObservationBuilder {
       metricValues.alias ? ` (${metricValues.alias})` : ""
     } recorded ${summary}.`;
   }
+
+  /*
+   * Best-effort unit conversion for observation text. Mirrors the
+   * sample→thresholdUnit conversion in MetricMonitorCriteria so the
+   * "recorded" message and the breach comparison speak the same unit.
+   * Returns the input array unchanged when units are missing or
+   * incompatible — never throws.
+   */
+  private static convertMetricValuesToThresholdUnit(input: {
+    values: Array<number>;
+    criteriaFilter: CriteriaFilter;
+    dataToProcess: DataToProcess;
+    monitorStep: MonitorStep;
+    alias: string | null;
+  }): Array<number> {
+    const thresholdUnit: string | undefined =
+      input.criteriaFilter.metricMonitorOptions?.thresholdUnit;
+    if (!thresholdUnit) {
+      return input.values;
+    }
+
+    const metricResponse: MetricMonitorResponse | null =
+      MonitorCriteriaDataExtractor.getMetricMonitorResponse(
+        input.dataToProcess,
+      );
+    if (!metricResponse) {
+      return input.values;
+    }
+
+    const queryConfigs: Array<MetricQueryConfigData> =
+      input.monitorStep.data?.metricMonitor?.metricViewConfig?.queryConfigs ||
+      [];
+    const formulaConfigs: Array<MetricFormulaConfigData> =
+      input.monitorStep.data?.metricMonitor?.metricViewConfig?.formulaConfigs ||
+      [];
+
+    const alias: string | null = input.alias;
+    const matchedQuery: MetricQueryConfigData | undefined = alias
+      ? queryConfigs.find((q: MetricQueryConfigData) => {
+          return q.metricAliasData?.metricVariable === alias;
+        })
+      : queryConfigs[0];
+    const matchedFormula: MetricFormulaConfigData | undefined =
+      !matchedQuery && alias
+        ? formulaConfigs.find((f: MetricFormulaConfigData) => {
+            return f.metricAliasData?.metricVariable === alias;
+          })
+        : undefined;
+
+    const rawMetricName: string | undefined =
+      (matchedQuery?.metricQueryData?.filterData?.metricName as
+        | string
+        | undefined) || undefined;
+    const nativeUnitFromMap: string | undefined = rawMetricName
+      ? metricResponse.nativeUnitsByMetricName?.[rawMetricName.toLowerCase()]
+      : undefined;
+
+    const sampleUnit: string | undefined =
+      (matchedQuery?.metricAliasData?.legendUnit as string | undefined) ||
+      (matchedFormula?.metricAliasData?.legendUnit as string | undefined) ||
+      nativeUnitFromMap ||
+      undefined;
+
+    if (!sampleUnit || sampleUnit === thresholdUnit) {
+      return input.values;
+    }
+
+    return input.values.map((v: number) => {
+      return MetricUnitUtil.convertToMetricUnit({
+        value: v,
+        fromUnit: sampleUnit,
+        metricUnit: thresholdUnit,
+      });
+    });
+  }
 }