@oneuptime/common 11.3.20 → 11.3.22

package/Server/Services/ScheduledMaintenanceService.ts

@@ -8,6 +8,8 @@ import ScheduledMaintenanceOwnerTeamService from "./ScheduledMaintenanceOwnerTea
 import ScheduledMaintenanceOwnerUserService from "./ScheduledMaintenanceOwnerUserService";
 import ScheduledMaintenanceStateService from "./ScheduledMaintenanceStateService";
 import ScheduledMaintenanceStateTimelineService from "./ScheduledMaintenanceStateTimelineService";
+import ScheduledMaintenanceReminderRuleService from "./ScheduledMaintenanceReminderRuleService";
+import ScheduledMaintenanceReminderRule from "../../Models/DatabaseModels/ScheduledMaintenanceReminderRule";
 import TeamMemberService from "./TeamMemberService";
 import URL from "../../Types/API/URL";
 import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
@@ -809,6 +811,80 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
     return { createBy, carryForward: null };
   }
 
+  @CaptureSpan()
+  public async refreshReminderSchedule(data: {
+    scheduledMaintenanceId: ObjectID;
+    projectId: ObjectID;
+  }): Promise<void> {
+    const scheduledMaintenance: Model | null = await this.findOneById({
+      id: data.scheduledMaintenanceId,
+      select: {
+        enableReminders: true,
+        startsAt: true,
+        labels: {
+          _id: true,
+        },
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!scheduledMaintenance) {
+      return;
+    }
+
+    let nextReminderNotificationAt: Date | null = null;
+
+    if (scheduledMaintenance.enableReminders !== false) {
+      const matchingRule: ScheduledMaintenanceReminderRule | null =
+        await ScheduledMaintenanceReminderRuleService.findMatchingRule({
+          projectId: data.projectId,
+          labelIds: scheduledMaintenance.labels?.map((label: Label) => {
+            return label.id!;
+          }),
+        });
+
+      if (
+        matchingRule &&
+        matchingRule.reminderIntervalInMinutes &&
+        !(await this.isScheduledMaintenanceCompleted({
+          scheduledMaintenanceId: data.scheduledMaintenanceId,
+        }))
+      ) {
+        /*
+         * When the rule does not remind while the event is still scheduled,
+         * defer the first reminder until after the event has started so that
+         * owners are not notified about an event that has not begun yet.
+         */
+        let referenceDate: Date = OneUptimeDate.getCurrentDate();
+
+        if (
+          !matchingRule.remindWhileScheduled &&
+          scheduledMaintenance.startsAt &&
+          OneUptimeDate.isInTheFuture(scheduledMaintenance.startsAt)
+        ) {
+          referenceDate = scheduledMaintenance.startsAt;
+        }
+
+        nextReminderNotificationAt = OneUptimeDate.addRemoveMinutes(
+          referenceDate,
+          matchingRule.reminderIntervalInMinutes,
+        );
+      }
+    }
+
+    await this.updateOneById({
+      id: data.scheduledMaintenanceId,
+      data: {
+        nextReminderNotificationAt: nextReminderNotificationAt,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
   @CaptureSpan()
   protected override async onCreateSuccess(
     onCreate: OnCreate<Model>,
@@ -985,6 +1061,26 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
           );
         }
       })
+      .then(async () => {
+        // Schedule reminder notifications for scheduled maintenance if a matching reminder rule exists
+        try {
+          if (createdItem.projectId && createdItem.id) {
+            await this.refreshReminderSchedule({
+              scheduledMaintenanceId: createdItem.id,
+              projectId: createdItem.projectId,
+            });
+          }
+        } catch (error) {
+          logger.error(
+            `Reminder scheduling failed in ScheduledMaintenanceService.onCreateSuccess: ${error}`,
+            {
+              projectId: createdItem.projectId?.toString(),
+              scheduledMaintenanceId: createdItem.id?.toString(),
+              userId: createdItem.createdByUserId?.toString(),
+            } as LogAttributes,
+          );
+        }
+      })
       .catch((error: Error) => {
         logger.error(
           `Critical error in ScheduledMaintenanceService sequential operations: ${error}`,
@@ -1577,6 +1673,37 @@ ${labels
             },
           );
         }
+
+        /*
+         * Re-evaluate reminder schedule when reminders are enabled or disabled,
+         * or when labels change (which may change the matching reminder rule).
+         */
+        if (
+          onUpdate.updateBy.props.tenantId &&
+          (Object.prototype.hasOwnProperty.call(
+            onUpdate.updateBy.data,
+            "enableReminders",
+          ) ||
+            Object.prototype.hasOwnProperty.call(
+              onUpdate.updateBy.data,
+              "labels",
+            ))
+        ) {
+          try {
+            await this.refreshReminderSchedule({
+              scheduledMaintenanceId: scheduledMaintenanceId,
+              projectId: onUpdate.updateBy.props.tenantId as ObjectID,
+            });
+          } catch (reminderError) {
+            logger.error(
+              `Reminder rescheduling failed in ScheduledMaintenanceService.onUpdateSuccess: ${reminderError}`,
+              {
+                projectId: onUpdate.updateBy.props.tenantId?.toString(),
+                scheduledMaintenanceId: scheduledMaintenanceId?.toString(),
+              } as LogAttributes,
+            );
+          }
+        }
       }
     }
 

package/Server/Services/StatusPageService.ts

@@ -37,6 +37,7 @@ import User from "../../Models/DatabaseModels/User";
 import {
   AllowedStatusPageCountInFreePlan,
   IsBillingEnabled,
+  LetsEncryptAccountKey,
 } from "../EnvironmentConfig";
 import { PlanType } from "../../Types/Billing/SubscriptionPlan";
 import Recurring from "../../Types/Events/Recurring";
@@ -96,9 +97,9 @@ export class Service extends DatabaseService<StatusPage> {
    * Caches the resolved status page URL per statusPageId. `getStatusPageURL`
    * is called inside per-subscriber notification loops (see
    * `StatusPageSubscriberService`), where a single batch can fire N×
-   * Postgres lookups against `StatusPageDomain`. SSL-provisioned custom
-   * domains change rarely (provisioning takes minutes), so a 60s staleness
-   * window is acceptable. Callers that need stronger consistency can call
+   * Postgres lookups against `StatusPageDomain`. Usable custom domains
+   * change rarely (provisioning/verification takes minutes), so a 60s
+   * staleness window is acceptable. Callers that need stronger consistency can call
    * `clearStatusPageUrlCache` after writes to the underlying domain.
    */
   private statusPageUrlCache: InMemoryTTLCache<string> = new InMemoryTTLCache(
@@ -679,32 +680,107 @@ export class Service extends DatabaseService<StatusPage> {
     return monitorStatusTimelines;
   }
 
+  /*
+   * Picks the custom domain to use when linking to this status page from
+   * subscriber notifications (email/SMS/Slack/Teams/webhooks) and SSO
+   * redirects. A domain is usable when any of these holds, in order of
+   * preference:
+   * 1. `isSslProvisioned` — OneUptime ordered the certificate and confirmed
+   *    the domain serves HTTPS.
+   * 2. `isCustomCertificate` + `isCnameVerified` — the user uploaded their
+   *    own certificate (the SSL provisioning jobs skip these domains, so
+   *    `isSslProvisioned` never becomes true for them) and the CNAME check
+   *    confirmed the domain actually routes to this instance. CNAME alone
+   *    guards against certs uploaded before DNS is pointed.
+   * 3. `isCnameVerified`, but only when this instance has no Let's Encrypt
+   *    account key — self-hosted installs that terminate TLS at their own
+   *    proxy can never provision SSL, so CNAME verification is the
+   *    strongest available signal that the domain routes to this instance.
+   *    (With Let's Encrypt configured, a verified-but-unprovisioned domain
+   *    is just mid-provisioning and will be picked up by rule 1 shortly.)
+   * Without rules 2 and 3, such status pages fall back to the installation
+   * URL in every subscriber notification
+   * (https://github.com/OneUptime/oneuptime/issues/1951).
+   */
   @CaptureSpan()
-  public async getStatusPageURL(statusPageId: ObjectID): Promise<string> {
-    const cacheKey: string = statusPageId.toString();
-    const cached: string | undefined = this.statusPageUrlCache.get(cacheKey);
-    if (cached !== undefined) {
-      return cached;
-    }
-
-    const domain: StatusPageDomain | null =
-      await StatusPageDomainService.findOneBy({
+  public async getUsableCustomDomain(
+    statusPageId: ObjectID,
+  ): Promise<StatusPageDomain | null> {
+    const domains: Array<StatusPageDomain> =
+      await StatusPageDomainService.findBy({
         query: {
           statusPageId: statusPageId,
-          isSslProvisioned: true,
         },
         select: {
           fullDomain: true,
+          isSslProvisioned: true,
+          isCustomCertificate: true,
+          isCnameVerified: true,
         },
+        skip: 0,
+        limit: LIMIT_PER_PROJECT,
         props: {
           isRoot: true,
           ignoreHooks: true,
         },
       });
 
-    let statusPageURL: string = domain?.fullDomain
-      ? `https://${domain.fullDomain}`
-      : "";
+    const domainsWithFullDomain: Array<StatusPageDomain> = domains.filter(
+      (domain: StatusPageDomain) => {
+        return Boolean(domain.fullDomain);
+      },
+    );
+
+    return (
+      domainsWithFullDomain.find((domain: StatusPageDomain) => {
+        return domain.isSslProvisioned;
+      }) ||
+      domainsWithFullDomain.find((domain: StatusPageDomain) => {
+        return domain.isCustomCertificate && domain.isCnameVerified;
+      }) ||
+      (!LetsEncryptAccountKey
+        ? domainsWithFullDomain.find((domain: StatusPageDomain) => {
+            return domain.isCnameVerified;
+          })
+        : undefined) ||
+      null
+    );
+  }
+
+  /*
+   * SSL-provisioned and custom-certificate domains are known to serve
+   * HTTPS. A CNAME-verified-only domain (self-hosted instance behind the
+   * user's own proxy) follows the instance protocol instead — CNAME
+   * verification can succeed over plain HTTP, so an HTTP-only install
+   * gets http:// links that actually work.
+   */
+  private async getProtocolForCustomDomain(
+    domain: StatusPageDomain,
+  ): Promise<Protocol> {
+    if (domain.isSslProvisioned || domain.isCustomCertificate) {
+      return Protocol.HTTPS;
+    }
+
+    return DatabaseConfig.getHttpProtocol();
+  }
+
+  @CaptureSpan()
+  public async getStatusPageURL(statusPageId: ObjectID): Promise<string> {
+    const cacheKey: string = statusPageId.toString();
+    const cached: string | undefined = this.statusPageUrlCache.get(cacheKey);
+    if (cached !== undefined) {
+      return cached;
+    }
+
+    const domain: StatusPageDomain | null =
+      await this.getUsableCustomDomain(statusPageId);
+
+    let statusPageURL: string = "";
+
+    if (domain?.fullDomain) {
+      const protocol: Protocol = await this.getProtocolForCustomDomain(domain);
+      statusPageURL = `${protocol}${domain.fullDomain}`;
+    }
 
     if (!statusPageURL) {
       const host: Hostname = await DatabaseConfig.getHost();
@@ -724,39 +800,22 @@ export class Service extends DatabaseService<StatusPage> {
 
   @CaptureSpan()
   public async getStatusPageFirstURL(statusPageId: ObjectID): Promise<string> {
-    const domains: Array<StatusPageDomain> =
-      await StatusPageDomainService.findBy({
-        query: {
-          statusPageId: statusPageId,
-          isSslProvisioned: true,
-        },
-        select: {
-          fullDomain: true,
-        },
-        skip: 0,
-        limit: LIMIT_PER_PROJECT,
-        props: {
-          isRoot: true,
-          ignoreHooks: true,
-        },
-      });
-
-    let statusPageURL: string = "";
+    const domain: StatusPageDomain | null =
+      await this.getUsableCustomDomain(statusPageId);
 
-    if (domains.length === 0) {
-      const host: Hostname = await DatabaseConfig.getHost();
+    if (domain?.fullDomain) {
+      const protocol: Protocol = await this.getProtocolForCustomDomain(domain);
+      return `${protocol}${domain.fullDomain}`;
+    }
 
-      const httpProtocol: Protocol = await DatabaseConfig.getHttpProtocol();
+    const host: Hostname = await DatabaseConfig.getHost();
 
-      // 'https://local.oneuptime.com/status-page/40092fb5-cc33-4995-b532-b4e49c441c98'
-      statusPageURL = new URL(httpProtocol, host)
-        .addRoute("/status-page/" + statusPageId.toString())
-        .toString();
-    } else {
-      statusPageURL = domains[0]?.fullDomain || "";
-    }
+    const httpProtocol: Protocol = await DatabaseConfig.getHttpProtocol();
 
-    return statusPageURL;
+    // 'https://local.oneuptime.com/status-page/40092fb5-cc33-4995-b532-b4e49c441c98'
+    return new URL(httpProtocol, host)
+      .addRoute("/status-page/" + statusPageId.toString())
+      .toString();
   }
 
   @CaptureSpan()

package/Server/Services/TelemetryExceptionService.ts

@@ -15,6 +15,17 @@ import AIAgentTaskTelemetryExceptionService from "./AIAgentTaskTelemetryExceptio
 import QueryHelper from "../Types/Database/QueryHelper";
 import ModelPermission from "../Types/Database/Permissions/Index";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import Query from "../Types/Database/Query";
+import Includes from "../../Types/BaseDatabase/Includes";
+import logger from "../Utils/Logger";
+
+/*
+ * Hard cap on the fingerprint NOT IN list handed to the ClickHouse count
+ * query. ClickHouse receives query params via the request URI (default
+ * http_max_uri_size 1 MiB ≈ 14k sha256 fingerprints); 5k keeps a wide
+ * safety margin while covering all realistic projects.
+ */
+export const EXCLUDED_FINGERPRINT_LIMIT: number = 5000;
 
 export interface CreateAIAgentTaskForExceptionParams {
   telemetryExceptionId: ObjectID;
@@ -263,6 +274,118 @@ export class Service extends DatabaseService<Model> {
     };
   }
 
+  /**
+   * Fingerprints of exception groups marked resolved and/or archived —
+   * used by the exception monitor to exclude occurrences of those groups
+   * from the exception count. Resolution state lives on this Postgres
+   * model per (projectId, primaryEntityId, fingerprint) group, while
+   * occurrences live in ClickHouse; fingerprints are the join key.
+   * Fingerprints hash projectId + primaryEntityId into the digest, so a
+   * fingerprint never collides across services and excluding by
+   * fingerprint alone is exact.
+   *
+   * The result is capped at EXCLUDED_FINGERPRINT_LIMIT, keeping the most
+   * recently seen groups: the ClickHouse client ships query params in the
+   * request URI, so an unbounded NOT IN list would blow past ClickHouse's
+   * http_max_uri_size (~1 MiB, roughly 14k fingerprints) and hard-fail the
+   * monitor's count query. Overflow groups simply stay counted (fail-open:
+   * better a stale incident than a silently swallowed one), and the
+   * lastSeenAt-descending order means what gets dropped is the groups
+   * least likely to have occurrences in the monitor window.
+   *
+   * Deliberately NO lastSeenAt lower bound: ExceptionInstance.time is the
+   * client-reported occurrence timestamp while lastSeenAt is server-side
+   * ingest time, so any window-derived cutoff breaks under client clock
+   * skew (and under monitor configs with no time window at all).
+   */
+  @CaptureSpan()
+  public async getResolvedOrArchivedFingerprints(data: {
+    projectId: ObjectID;
+    telemetryServiceIds?: Array<ObjectID> | undefined;
+    resolved: boolean;
+    archived: boolean;
+  }): Promise<Array<string>> {
+    const statusFilters: Array<Query<Model>> = [];
+
+    if (data.resolved) {
+      statusFilters.push({ isResolved: true });
+    }
+
+    if (data.archived) {
+      statusFilters.push({ isArchived: true });
+    }
+
+    if (statusFilters.length === 0) {
+      return [];
+    }
+
+    // resolved-OR-archived needs two indexed lookups — findBy has no OR.
+    const resultsPerStatus: Array<Array<Model>> = await Promise.all(
+      statusFilters.map(
+        async (statusFilter: Query<Model>): Promise<Array<Model>> => {
+          const query: Query<Model> = {
+            projectId: data.projectId,
+            ...statusFilter,
+          };
+
+          if (data.telemetryServiceIds && data.telemetryServiceIds.length > 0) {
+            query.primaryEntityId = new Includes(data.telemetryServiceIds);
+          }
+
+          /*
+           * Per-status limit equals the final cap: the merged most-recent
+           * EXCLUDED_FINGERPRINT_LIMIT groups are necessarily within the
+           * top EXCLUDED_FINGERPRINT_LIMIT of their own status query.
+           */
+          return this.findBy({
+            query: query,
+            select: {
+              fingerprint: true,
+              lastSeenAt: true,
+            },
+            sort: {
+              lastSeenAt: SortOrder.Descending,
+            },
+            limit: EXCLUDED_FINGERPRINT_LIMIT,
+            skip: 0,
+            props: {
+              isRoot: true,
+            },
+          });
+        },
+      ),
+    );
+
+    // Merge the status lists most-recently-seen first, dedupe, then cap.
+    const merged: Array<Model> = resultsPerStatus
+      .flat()
+      .sort((a: Model, b: Model): number => {
+        return (b.lastSeenAt?.getTime() || 0) - (a.lastSeenAt?.getTime() || 0);
+      });
+
+    const fingerprints: Set<string> = new Set<string>();
+    let truncated: boolean = false;
+
+    for (const exception of merged) {
+      if (!exception.fingerprint) {
+        continue;
+      }
+      if (fingerprints.size >= EXCLUDED_FINGERPRINT_LIMIT) {
+        truncated = true;
+        break;
+      }
+      fingerprints.add(exception.fingerprint);
+    }
+
+    if (truncated) {
+      logger.warn(
+        `TelemetryException fingerprint exclusion list for project ${data.projectId.toString()} exceeds ${EXCLUDED_FINGERPRINT_LIMIT}; least recently seen resolved/archived exception groups will still be counted by exception monitors.`,
+      );
+    }
+
+    return Array.from(fingerprints);
+  }
+
   @CaptureSpan()
   private async aggregateUnresolvedByService(
     projectId: ObjectID,

package/Server/Services/UserNotificationSettingService.ts

@@ -580,6 +580,18 @@ export class Service extends DatabaseService<UserNotificationSetting> {
     await this.addAlertNotificationSettings(userId, projectId);
     await this.addAlertEpisodeNotificationSettings(userId, projectId);
     await this.addIncidentEpisodeNotificationSettings(userId, projectId);
+    await this.addScheduledMaintenanceNotificationSettings(userId, projectId);
+  }
+
+  private async addScheduledMaintenanceNotificationSettings(
+    userId: ObjectID,
+    projectId: ObjectID,
+  ): Promise<void> {
+    await this.addNotificationSettingIfNotExists(
+      userId,
+      projectId,
+      NotificationSettingEventType.SEND_SCHEDULED_MAINTENANCE_REMINDER_OWNER_NOTIFICATION,
+    );
   }
 
   private async addProbeOwnerNotificationSettings(
@@ -614,6 +626,12 @@ export class Service extends DatabaseService<UserNotificationSetting> {
       projectId,
       NotificationSettingEventType.SEND_INCIDENT_STATE_CHANGED_OWNER_NOTIFICATION,
     );
+
+    await this.addNotificationSettingIfNotExists(
+      userId,
+      projectId,
+      NotificationSettingEventType.SEND_INCIDENT_REMINDER_OWNER_NOTIFICATION,
+    );
   }
 
   private async addMonitorNotificationSettings(
@@ -689,6 +707,12 @@ export class Service extends DatabaseService<UserNotificationSetting> {
       projectId,
       NotificationSettingEventType.SEND_ALERT_STATE_CHANGED_OWNER_NOTIFICATION,
     );
+
+    await this.addNotificationSettingIfNotExists(
+      userId,
+      projectId,
+      NotificationSettingEventType.SEND_ALERT_REMINDER_OWNER_NOTIFICATION,
+    );
   }
 
   private async addAlertEpisodeNotificationSettings(

package/Server/Utils/AnalyticsDatabase/Statement.ts

@@ -5,6 +5,7 @@ import TableColumnType from "../../../Types/AnalyticsDatabase/TableColumnType";
 import GreaterThan from "../../../Types/BaseDatabase/GreaterThan";
 import GreaterThanOrEqual from "../../../Types/BaseDatabase/GreaterThanOrEqual";
 import Includes from "../../../Types/BaseDatabase/Includes";
+import IncludesNone from "../../../Types/BaseDatabase/IncludesNone";
 import LessThan from "../../../Types/BaseDatabase/LessThan";
 import LessThanOrEqual from "../../../Types/BaseDatabase/LessThanOrEqual";
 import LessThanOrNull from "../../../Types/BaseDatabase/LessThanOrNull";
@@ -108,7 +109,7 @@ export class Statement implements BaseQueryParams {
       v.value instanceof NotEqual
     ) {
       finalValue = v.value.value;
-    } else if (v.value instanceof Includes) {
+    } else if (v.value instanceof Includes || v.value instanceof IncludesNone) {
       if (
         v.type === TableColumnType.Text ||
         v.type === TableColumnType.ObjectID
@@ -198,9 +199,12 @@ export class Statement implements BaseQueryParams {
       [TableColumnType.UInt64]: "UInt64",
     };
 
-    if ((statementParam as StatementParameter).value instanceof Includes) {
+    if (
+      (statementParam as StatementParameter).value instanceof Includes ||
+      (statementParam as StatementParameter).value instanceof IncludesNone
+    ) {
       const includesValues: Array<string | number | ObjectID> = (
-        (statementParam as StatementParameter).value as Includes
+        (statementParam as StatementParameter).value as Includes | IncludesNone
       ).values as Array<string | number | ObjectID>;
 
       const isNumberArray: boolean = includesValues.every(

package/Server/Utils/AnalyticsDatabase/StatementGenerator.ts

@@ -675,6 +675,41 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
             type: tableColumn.type,
           }}`,
         );
+      } else if (
+        value instanceof IncludesNone &&
+        tableColumn.type === TableColumnType.ArrayText
+      ) {
+        /*
+         * Array(String) exclusion — the negation of the Includes/hasAny
+         * branch above. An empty IncludesNone excludes nothing, so it
+         * drops to no predicate (mirrors the empty-Includes behavior).
+         */
+        const arrayExcludeValues: Array<string> =
+          ((value as IncludesNone).values as Array<string>) || [];
+        if (arrayExcludeValues.length > 0) {
+          whereStatement.append(
+            SQL`AND NOT hasAny(${key}, ${{
+              value: arrayExcludeValues,
+              type: TableColumnType.ArrayText,
+            }})`,
+          );
+        }
+      } else if (value instanceof IncludesNone) {
+        /*
+         * Scalar exclusion ("is none of"): `col NOT IN (v1, v2, ...)`.
+         * An empty IncludesNone means "exclude nothing" — skip the
+         * predicate entirely rather than emitting `NOT IN ()`.
+         */
+        const excludeValues: Array<string | ObjectID | number> =
+          ((value as IncludesNone).values as Array<string | ObjectID>) || [];
+        if (excludeValues.length > 0) {
+          whereStatement.append(
+            SQL`AND ${key} NOT IN ${{
+              value: value,
+              type: tableColumn.type,
+            }}`,
+          );
+        }
       } else if (value instanceof IsNull) {
         if (tableColumn.type === TableColumnType.Text) {
           whereStatement.append(SQL`AND (${key} IS NULL OR ${key} = '')`);

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

@@ -3,6 +3,7 @@ import AggregatedResult from "../../../../Types/BaseDatabase/AggregatedResult";
 import MetricFormulaConfigData from "../../../../Types/Metrics/MetricFormulaConfigData";
 import MetricQueryConfigData from "../../../../Types/Metrics/MetricQueryConfigData";
 import MetricsAggregationType from "../../../../Types/Metrics/MetricsAggregationType";
+import MetricsViewConfig from "../../../../Types/Metrics/MetricsViewConfig";
 import MetricMonitorResponse from "../../../../Types/Monitor/MetricMonitor/MetricMonitorResponse";
 import MetricCriteriaContext, {
   MetricAnomalyBaseline,
@@ -114,12 +115,13 @@ export default class MetricMonitorCriteria {
     const seriesBreakdown: Array<MetricSeriesResult> | undefined =
       metricResponse.seriesBreakdown;
 
+    const metricViewConfig: MetricsViewConfig | undefined =
+      MonitorStep.getMetricsViewConfig(input.monitorStep);
+
     const queryConfigs: Array<MetricQueryConfigData> =
-      input.monitorStep.data?.metricMonitor?.metricViewConfig?.queryConfigs ||
-      [];
+      metricViewConfig?.queryConfigs || [];
     const formulaConfigs: Array<MetricFormulaConfigData> =
-      input.monitorStep.data?.metricMonitor?.metricViewConfig?.formulaConfigs ||
-      [];
+      metricViewConfig?.formulaConfigs || [];
 
     const nativeUnitsByMetricName: { [key: string]: string } | undefined =
       metricResponse.nativeUnitsByMetricName;

package/Server/Utils/Monitor/MonitorCriteriaDataExtractor.ts

@@ -14,6 +14,7 @@ import AggregatedResult from "../../../Types/BaseDatabase/AggregatedResult";
 import AggregateModel from "../../../Types/BaseDatabase/AggregatedModel";
 import MetricQueryConfigData from "../../../Types/Metrics/MetricQueryConfigData";
 import MetricFormulaConfigData from "../../../Types/Metrics/MetricFormulaConfigData";
+import MetricsViewConfig from "../../../Types/Metrics/MetricsViewConfig";
 import ExceptionMonitorResponse from "../../../Types/Monitor/ExceptionMonitor/ExceptionMonitorResponse";
 
 export default class MonitorCriteriaDataExtractor {
@@ -156,10 +157,12 @@ export default class MonitorCriteriaDataExtractor {
 
     let result: AggregatedResult | undefined;
 
+    const metricViewConfig: MetricsViewConfig | undefined =
+      MonitorStep.getMetricsViewConfig(input.monitorStep);
+
     if (alias) {
       const queryConfigs: Array<MetricQueryConfigData> =
-        input.monitorStep.data?.metricMonitor?.metricViewConfig?.queryConfigs ||
-        [];
+        metricViewConfig?.queryConfigs || [];
 
       let aliasIndex: number = queryConfigs.findIndex(
         (queryConfig: MetricQueryConfigData) => {
@@ -169,8 +172,7 @@ export default class MonitorCriteriaDataExtractor {
 
       if (aliasIndex < 0) {
         const formulaConfigs: Array<MetricFormulaConfigData> =
-          input.monitorStep.data?.metricMonitor?.metricViewConfig
-            ?.formulaConfigs || [];
+          metricViewConfig?.formulaConfigs || [];
 
         const formulaIndex: number = formulaConfigs.findIndex(
           (formulaConfig: MetricFormulaConfigData) => {
@@ -192,8 +194,7 @@ export default class MonitorCriteriaDataExtractor {
       result = aggregatedResults[0];
       if (!alias) {
         const defaultAlias: string | undefined =
-          input.monitorStep.data?.metricMonitor?.metricViewConfig
-            ?.queryConfigs?.[0]?.metricAliasData?.metricVariable;
+          metricViewConfig?.queryConfigs?.[0]?.metricAliasData?.metricVariable;
         alias = defaultAlias || null;
       }
     }