@oneuptime/common 10.4.13 → 10.4.15

package/Server/Services/MetricService.ts

@@ -4,12 +4,15 @@ import Metric from "../../Models/AnalyticsModels/Metric";
 import AggregateBy, {
   AggregateUtil,
 } from "../Types/AnalyticsDatabase/AggregateBy";
+import DeleteBy from "../Types/AnalyticsDatabase/DeleteBy";
+import Query from "../Types/AnalyticsDatabase/Query";
 import { SQL, Statement } from "../Utils/AnalyticsDatabase/Statement";
 import AggregationType, {
   getPercentileLevel,
   isPercentileAggregation,
 } from "../../Types/BaseDatabase/AggregationType";
 import AggregationInterval from "../../Types/BaseDatabase/AggregationInterval";
+import AnalyticsTableName from "../../Types/AnalyticsDatabase/AnalyticsTableName";
 import TableColumnType from "../../Types/AnalyticsDatabase/TableColumnType";
 import logger, { LogAttributes } from "../Utils/Logger";
 
@@ -18,6 +21,116 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
     super({ modelType: Metric, database: clickhouseDatabase });
   }
 
+  /*
+   * Cascade deletes from `MetricItemV2` into the aggregating
+   * materialized-view target tables.
+   *
+   * `MetricItemAggMV1m` and `MetricBaselineHourly` are AggregatingMergeTree
+   * tables populated by attached MVs that only fire on inserts —
+   * `ALTER ... DELETE` against the source table does not roll back the
+   * previously-accumulated `sumState`/`countState` rows already in the MV
+   * tables. Without a matching DELETE on each MV, dashboard widgets that
+   * read from `MetricItemAggMV1m` keep counting and averaging metrics
+   * belonging to entities (incidents, alerts) the user has just deleted.
+   * See https://github.com/OneUptime/oneuptime/issues/2419.
+   *
+   * The cascade only runs when the caller scoped the delete by
+   * `serviceId`. Global time-based purges (TTL cleanup) are handled by
+   * each MV table's own `retentionDate TTL DELETE`, so cascading those
+   * would pointlessly scan the whole MV. The per-host MV
+   * (`MetricItemAggMV1mByHost`) is keyed by `hostIdentifier` rather than
+   * `serviceId`, so a service-scoped delete has nothing to remove there —
+   * skip it.
+   */
+  public override async deleteBy(deleteBy: DeleteBy<Metric>): Promise<void> {
+    await super.deleteBy(deleteBy);
+
+    const cascadeQuery: Query<Metric> | null = this.buildMVCascadeQuery(
+      deleteBy.query,
+    );
+    if (!cascadeQuery) {
+      return;
+    }
+
+    if (!this.database) {
+      this.useDefaultDatabase();
+    }
+    const databaseName: string = this.database.getDatasourceOptions().database!;
+    const whereStatement: Statement =
+      this.statementGenerator.toWhereStatement(cascadeQuery);
+
+    const cascadeTargets: ReadonlyArray<AnalyticsTableName> = [
+      AnalyticsTableName.MetricItemAggMV1m,
+      AnalyticsTableName.MetricBaselineHourly,
+    ];
+
+    for (const tableName of cascadeTargets) {
+      try {
+        /*
+         * Lightweight delete — see toDeleteStatement() in
+         * AnalyticsDatabaseService for the rationale (avoids the
+         * ALTER mutations queue which is capped at 1000 per table).
+         */
+        const statement: Statement =
+          SQL`DELETE FROM ${databaseName}.${tableName} WHERE TRUE `.append(
+            whereStatement,
+          );
+        await this.execute(statement);
+      } catch (err) {
+        logger.error(
+          `Cascade delete into ${tableName} failed; dashboard widgets reading from this MV may temporarily show stale aggregated values for the deleted entity.`,
+        );
+        logger.error(err);
+      }
+    }
+  }
+
+  private buildMVCascadeQuery(query: Query<Metric>): Query<Metric> | null {
+    if (!query || typeof query !== "object") {
+      return null;
+    }
+
+    const queryRecord: Record<string, unknown> = query as unknown as Record<
+      string,
+      unknown
+    >;
+
+    /*
+     * Cascade only when the delete is scoped by serviceId. The MV sort
+     * key is (projectId, name, serviceId, bucketTime); without serviceId
+     * the DELETE would scan a huge swath of unrelated rows and risk
+     * removing data that belongs to other entities sharing the same
+     * project.
+     */
+    if (
+      queryRecord["serviceId"] === undefined ||
+      queryRecord["serviceId"] === null
+    ) {
+      return null;
+    }
+
+    /*
+     * Only project the keys the MV target tables actually expose.
+     * `time`, `attributes`, `serviceType`, and the metric-payload
+     * columns don't exist on the MV schema and would either fail
+     * where-statement generation or reference a missing column.
+     */
+    const allowedKeys: ReadonlyArray<string> = [
+      "projectId",
+      "name",
+      "serviceId",
+    ];
+    const out: Record<string, unknown> = {};
+    for (const key of allowedKeys) {
+      const value: unknown = queryRecord[key];
+      if (value !== undefined) {
+        out[key] = value;
+      }
+    }
+
+    return out as unknown as Query<Metric>;
+  }
+
   /**
    * Histogram-aware aggregation override.
    *

package/Server/Services/MonitorService.ts

@@ -1563,9 +1563,16 @@ ${createdItem.description?.trim() || "No description provided."}
       return;
     }
 
-    for (const monitorProbe of monitorProbes) {
-      await this.refreshMonitorProbeStatus(monitorProbe.monitorId!);
-    }
+    /*
+     * Each monitor appears at most once for a given probeId (composite
+     * unique on MonitorProbe), so concurrent refreshes operate on
+     * disjoint rows and are safe to run in parallel.
+     */
+    await Promise.all(
+      monitorProbes.map((monitorProbe: MonitorProbe) => {
+        return this.refreshMonitorProbeStatus(monitorProbe.monitorId!);
+      }),
+    );
   }
 
   @CaptureSpan()

package/Server/Services/ProjectService.ts

@@ -82,6 +82,7 @@ import DatabaseConfig from "../DatabaseConfig";
 import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
 import PositiveNumber from "../../Types/PositiveNumber";
 import Semaphore, { SemaphoreMutex } from "../Infrastructure/Semaphore";
+import InMemoryTTLCache from "../Infrastructure/InMemoryTTLCache";
 
 export interface CurrentPlan {
   plan: PlanType | null;
@@ -89,6 +90,30 @@ export interface CurrentPlan {
 }
 
 export class ProjectService extends DatabaseService<Model> {
+  /*
+   * Suppresses repeated `lastActive` UPDATEs from a single API node. 60s of
+   * staleness on "last seen" is acceptable; an UPDATE per request is not.
+   */
+  private lastActiveCache: InMemoryTTLCache<true> = new InMemoryTTLCache(
+    10_000,
+  );
+  /*
+   * Caches the `requireSsoForLogin` flag per project so middleware can skip a
+   * Postgres findOneById on every authenticated request.
+   */
+  private requireSsoForLoginCache: InMemoryTTLCache<boolean> =
+    new InMemoryTTLCache(10_000);
+  /*
+   * Caches the current billing plan per project. `getCurrentPlan` is hit
+   * by `CommonAPI.getDatabaseCommonInteractionProps` on every
+   * authenticated request when billing is enabled — without caching,
+   * that's one Postgres findOneById per API call to a billable project.
+   * Plans change rarely (subscription create / cancel / change), so a
+   * 60s staleness window is acceptable.
+   */
+  private currentPlanCache: InMemoryTTLCache<CurrentPlan> =
+    new InMemoryTTLCache(10_000);
+
   public constructor() {
     super(Model);
   }
@@ -318,6 +343,14 @@ export class ProjectService extends DatabaseService<Model> {
   protected override async onBeforeUpdate(
     updateBy: UpdateBy<Model>,
   ): Promise<OnUpdate<Model>> {
+    /*
+     * Any project field could have changed; invalidate the in-process cache
+     * of the SSO flag. Cheap to refetch on the next request.
+     */
+    if (updateBy.data.requireSsoForLogin !== undefined) {
+      this.requireSsoForLoginCache.clear();
+    }
+
     if (IsBillingEnabled) {
       if (
         updateBy.data.businessDetails ||
@@ -1251,7 +1284,21 @@ export class ProjectService extends DatabaseService<Model> {
 
   @CaptureSpan()
   public async updateLastActive(projectId: ObjectID): Promise<void> {
-    await this.updateOneById({
+    const key: string = projectId.toString();
+    if (this.lastActiveCache.has(key)) {
+      return;
+    }
+    /*
+     * Set BEFORE the await so a burst of concurrent requests collapses to one
+     * UPDATE per node per 60s window instead of all firing in parallel.
+     */
+    this.lastActiveCache.set(key, true, 60_000);
+
+    /*
+     * Fire-and-forget — `lastActive` is a soft-real-time field and the
+     * caller (auth middleware) shouldn't pay a Postgres round-trip for it.
+     */
+    void this.updateOneById({
       id: projectId,
       data: {
         lastActive: OneUptimeDate.getCurrentDate(),
@@ -1259,7 +1306,41 @@ export class ProjectService extends DatabaseService<Model> {
       props: {
         isRoot: true,
       },
+    }).catch((err: Error) => {
+      // Drop the cache entry so a retry can fire within the same TTL window.
+      this.lastActiveCache.delete(key);
+      logger.error(
+        `Failed to update Project.lastActive for ${key}: ${err.message}`,
+      );
+    });
+  }
+
+  /**
+   * Returns whether the given project requires SSO for login. Cached for
+   * 60s in-process — middleware calls this on every authenticated request.
+   */
+  @CaptureSpan()
+  public async getRequireSsoForLogin(projectId: ObjectID): Promise<boolean> {
+    const key: string = projectId.toString();
+    const cached: boolean | undefined = this.requireSsoForLoginCache.get(key);
+    if (cached !== undefined) {
+      return cached;
+    }
+
+    const project: Model | null = await this.findOneById({
+      id: projectId,
+      select: { requireSsoForLogin: true },
+      props: { isRoot: true },
     });
+
+    if (!project) {
+      // Don't cache "not found" — let the caller decide how to handle it.
+      throw new BadDataException("Project not found");
+    }
+
+    const value: boolean = Boolean(project.requireSsoForLogin);
+    this.requireSsoForLoginCache.set(key, value, 60_000);
+    return value;
   }
 
   @CaptureSpan()
@@ -1421,6 +1502,12 @@ export class ProjectService extends DatabaseService<Model> {
       return { plan: null, isSubscriptionUnpaid: false };
     }
 
+    const cacheKey: string = projectId.toString();
+    const cached: CurrentPlan | undefined = this.currentPlanCache.get(cacheKey);
+    if (cached !== undefined) {
+      return cached;
+    }
+
     const project: Model | null = await this.findOneById({
       id: projectId,
       select: {
@@ -1435,10 +1522,12 @@ export class ProjectService extends DatabaseService<Model> {
     });
 
     if (!project) {
+      // Don't cache "not found" — let the caller surface a fresh error.
       throw new BadDataException("Project ID is invalid");
     }
 
     if (!project.paymentProviderPlanId) {
+      // Don't cache "no plan" — the project may be mid-onboarding.
       throw new BadDataException("Project does not have any plans");
     }
 
@@ -1447,7 +1536,7 @@ export class ProjectService extends DatabaseService<Model> {
       getAllEnvVars(),
     );
 
-    return {
+    const result: CurrentPlan = {
       plan: plan,
       isSubscriptionUnpaid:
         !BillingService.isSubscriptionActive(
@@ -1457,6 +1546,8 @@ export class ProjectService extends DatabaseService<Model> {
           project.paymentProviderMeteredSubscriptionStatus!,
         ),
     };
+    this.currentPlanCache.set(cacheKey, result, 60_000);
+    return result;
   }
 
   @CaptureSpan()

package/Server/Services/TeamMemberService.ts

@@ -37,8 +37,19 @@ import User from "../../Models/DatabaseModels/User";
 import OnCallDutyPolicyTimeLogService from "./OnCallDutyPolicyTimeLogService";
 import OneUptimeDate from "../../Types/Date";
 import ProjectSCIMService from "./ProjectSCIMService";
+import InMemoryTTLCache from "../Infrastructure/InMemoryTTLCache";
 
 export class TeamMemberService extends DatabaseService<TeamMember> {
+  /*
+   * Caches the user's accepted team memberships per project. Auth middleware
+   * calls this on every authenticated request to evaluate the `Owned`
+   * permission scope; without the cache it's a Postgres findBy per request.
+   * 60s of staleness on team membership changes is acceptable; we also
+   * invalidate proactively when team membership writes happen.
+   */
+  private teamIdsForUserCache: InMemoryTTLCache<Array<string>> =
+    new InMemoryTTLCache(10_000);
+
   public constructor() {
     super(TeamMember);
   }
@@ -215,6 +226,14 @@ export class TeamMemberService extends DatabaseService<TeamMember> {
     userId: ObjectID,
     projectId: ObjectID,
   ): Promise<void> {
+    /*
+     * Invalidate the in-process cache of this user's team memberships in
+     * this project — membership just changed.
+     */
+    this.teamIdsForUserCache.delete(
+      `${userId.toString()}:${projectId.toString()}`,
+    );
+
     /// Refresh tokens.
     await AccessTokenService.refreshUserGlobalAccessPermission(userId);
 
@@ -545,6 +564,15 @@ export class TeamMemberService extends DatabaseService<TeamMember> {
     userId: ObjectID,
     projectId: ObjectID,
   ): Promise<Array<ObjectID>> {
+    const cacheKey: string = `${userId.toString()}:${projectId.toString()}`;
+    const cached: Array<string> | undefined =
+      this.teamIdsForUserCache.get(cacheKey);
+    if (cached !== undefined) {
+      return cached.map((id: string) => {
+        return new ObjectID(id);
+      });
+    }
+
     const members: Array<TeamMember> = await this.findBy({
       query: {
         userId: userId,
@@ -570,6 +598,14 @@ export class TeamMemberService extends DatabaseService<TeamMember> {
         teamIds.push(id);
       }
     }
+
+    this.teamIdsForUserCache.set(
+      cacheKey,
+      teamIds.map((id: ObjectID) => {
+        return id.toString();
+      }),
+      60_000,
+    );
     return teamIds;
   }
 }

package/Server/Services/UserService.ts

@@ -39,12 +39,50 @@ import BadDataException from "../../Types/Exception/BadDataException";
 import Name from "../../Types/Name";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import Timezone from "../../Types/Timezone";
+import InMemoryTTLCache from "../Infrastructure/InMemoryTTLCache";
 
 export class Service extends DatabaseService<Model> {
+  /*
+   * Suppresses repeated `lastActive` UPDATEs from a single API node. 60s of
+   * staleness on "last seen" is acceptable; an UPDATE per request is not.
+   */
+  private lastActiveCache: InMemoryTTLCache<true> = new InMemoryTTLCache(
+    10_000,
+  );
+
   public constructor() {
     super(Model);
   }
 
+  /**
+   * Debounced fire-and-forget update of `User.lastActive`. The auth
+   * middleware calls this on every authenticated request; without the cache
+   * we'd issue one Postgres UPDATE per request per user.
+   */
+  @CaptureSpan()
+  public async updateLastActive(userId: ObjectID): Promise<void> {
+    const key: string = userId.toString();
+    if (this.lastActiveCache.has(key)) {
+      return;
+    }
+    /*
+     * Set BEFORE the await so a burst of concurrent requests collapses to one
+     * UPDATE per node per 60s window.
+     */
+    this.lastActiveCache.set(key, true, 60_000);
+
+    void this.updateOneById({
+      id: userId,
+      data: { lastActive: OneUptimeDate.getCurrentDate() },
+      props: { isRoot: true },
+    }).catch((err: Error) => {
+      this.lastActiveCache.delete(key);
+      logger.error(
+        `Failed to update User.lastActive for ${key}: ${err.message}`,
+      );
+    });
+  }
+
   @CaptureSpan()
   public async getUserMarkdownString(data: {
     userId: ObjectID;

package/Server/Utils/Response.ts

@@ -121,6 +121,7 @@ export default class Response {
     list: Array<BaseModel | AnalyticsDataModel>,
     count: PositiveNumber | number,
     modelType: { new (): BaseModel | AnalyticsDataModel },
+    options?: { hasMore?: boolean | undefined } | undefined,
   ): void {
     if (!(count instanceof PositiveNumber)) {
       count = new PositiveNumber(count);
@@ -144,7 +145,7 @@ export default class Response {
       );
     }
 
-    return this.sendJsonArrayResponse(req, res, jsonArray, count);
+    return this.sendJsonArrayResponse(req, res, jsonArray, count, options);
   }
 
   @CaptureSpan()
@@ -194,6 +195,7 @@ export default class Response {
     res: ExpressResponse,
     list: Array<JSONObject>,
     count: PositiveNumber,
+    options?: { hasMore?: boolean | undefined } | undefined,
   ): void {
     const oneUptimeRequest: OneUptimeRequest = req as OneUptimeRequest;
     const oneUptimeResponse: OneUptimeResponse = res as OneUptimeResponse;
@@ -203,6 +205,7 @@ export default class Response {
       count: new PositiveNumber(0),
       skip: new PositiveNumber(0),
       limit: new PositiveNumber(0),
+      hasMore: options?.hasMore,
     });
 
     if (!list) {

package/Server/Utils/UserPermission/UserPermission.ts

@@ -10,6 +10,22 @@ import PermissionNamespace from "../../Types/Permission/PermissionNamespace";
 import CaptureSpan from "../Telemetry/CaptureSpan";
 
 export default class UserPermissionUtil {
+  /*
+   * Build the cache key for a (user, project) tenant-permission entry.
+   * The previous shape was `userId.toString() + projectId.toString()`
+   * with no separator — two distinct ObjectID pairs could in principle
+   * collide because plain concatenation has no boundary marker. Use a
+   * delimiter so the namespace is unambiguous, and route both the GET
+   * (here) and the SET (in `AccessTokenService.refreshUserTenant
+   * AccessPermission`) through this helper so they can't drift.
+   */
+  public static buildTenantPermissionCacheKey(
+    userId: ObjectID,
+    projectId: ObjectID,
+  ): string {
+    return `${userId.toString()}:${projectId.toString()}`;
+  }
+
   @CaptureSpan()
   public static async getUserTenantAccessPermissionFromCache(
     userId: ObjectID,
@@ -18,7 +34,7 @@ export default class UserPermissionUtil {
     const json: UserTenantAccessPermission | null =
       (await GlobalCache.getJSONObject(
         PermissionNamespace.ProjectPermission,
-        userId.toString() + projectId.toString(),
+        this.buildTenantPermissionCacheKey(userId, projectId),
       )) as UserTenantAccessPermission;
 
     if (json) {

package/Tests/Server/Services/AnalyticsDatabaseService.test.ts

@@ -357,8 +357,8 @@ describe("AnalyticsDatabaseService", () => {
       });
 
       expect(statement.query).toBe(
-        "ALTER TABLE {p0:Identifier}.{p1:Identifier}\n" +
-          "DELETE WHERE TRUE <where-statement>",
+        "DELETE FROM {p0:Identifier}.{p1:Identifier}\n" +
+          "WHERE TRUE <where-statement>",
       );
       expect(statement.query_params).toStrictEqual({
         p0: "oneuptime",

package/Types/API/HTTPResponse.ts

@@ -69,6 +69,19 @@ export default class HTTPResponse<
     this._skip = v;
   }
 
+  /*
+   * Optional. Set by analytics list endpoints that skip the expensive
+   * COUNT(*) and instead over-fetch by one row. When defined, `count`
+   * is only a lower bound — UI should drive next/prev from `hasMore`.
+   */
+  private _hasMore: boolean | undefined = undefined;
+  public get hasMore(): boolean | undefined {
+    return this._hasMore;
+  }
+  public set hasMore(v: boolean | undefined) {
+    this._hasMore = v;
+  }
+
   public constructor(
     statusCode: number,
     data: JSONObject | Array<JSONObject>,
@@ -86,6 +99,9 @@ export default class HTTPResponse<
       this.count = data["count"] as number;
       this.skip = data["skip"] as number;
       this.limit = data["limit"] as number;
+      if (Object.keys(data).includes("hasMore")) {
+        this.hasMore = data["hasMore"] as boolean;
+      }
       this.jsonData = JSONFunctions.deserializeArray(data["data"] as JSONArray);
     } else if (Array.isArray(data)) {
       this.jsonData = JSONFunctions.deserializeArray(data as JSONArray);

package/Types/BaseDatabase/ListResult.ts

@@ -9,4 +9,10 @@ export default interface ListResult<
   count: number;
   skip: number;
   limit: number;
+  /*
+   * Optional. When set, the analytics endpoint produced this result
+   * without a full COUNT(*) — `count` is only a lower bound. Drive
+   * pagination off `hasMore` rather than computing total pages.
+   */
+  hasMore?: boolean | undefined;
 }

package/Types/CustomField/CustomFieldType.ts

@@ -2,6 +2,8 @@ enum CustomFieldType {
   Text = "Text",
   Number = "Number",
   Boolean = "Boolean",
+  Dropdown = "Dropdown",
+  MultiSelectDropdown = "MultiSelectDropdown",
 }
 
 export default CustomFieldType;

package/Types/Date.ts

@@ -1554,7 +1554,15 @@ export default class OneUptimeDate {
           .toDate();
       }
 
-      return moment(trimmedDate).toDate();
+      /*
+       * moment.js throws on non-ISO formats like TLS cert dates ("Mar 31 00:00:00 2026 GMT").
+       * Fall back to native Date which handles this format correctly.
+       */
+      try {
+        return moment(trimmedDate).toDate();
+      } catch (_err: unknown) {
+        return new Date(trimmedDate);
+      }
     }
 
     if (

package/Types/ListData.ts

@@ -7,17 +7,27 @@ export default class ListData {
     count: PositiveNumber;
     skip: PositiveNumber;
     limit: PositiveNumber;
+    hasMore?: boolean | undefined;
   }) {
     this.data = obj.data;
     this.count = obj.count;
     this.skip = obj.skip;
     this.limit = obj.limit;
+    this.hasMore = obj.hasMore;
   }
 
   public data: JSONArray;
   public count: PositiveNumber;
   public skip: PositiveNumber;
   public limit: PositiveNumber;
+  /*
+   * When set, the response was produced without a full COUNT(*) — the
+   * server fetched LIMIT+1 rows and only knows whether at least one
+   * more page exists. `count` is still emitted as a lower-bound so
+   * older clients keep rendering, but UI that wants accurate "X of Y"
+   * should switch to `hasMore`-based pagination.
+   */
+  public hasMore?: boolean | undefined;
 
   public toJSON(): JSONObject {
     const json: JSONObject = {
@@ -27,6 +37,10 @@ export default class ListData {
       limit: this.limit.toNumber(),
     };
 
+    if (this.hasMore !== undefined) {
+      json["hasMore"] = this.hasMore;
+    }
+
     return json;
   }
 }

package/Types/Monitor/DnsMonitor/DnsMonitorResponse.ts

@@ -1,3 +1,4 @@
+import ProbeAttempt from "../../Probe/ProbeAttempt";
 import DnsRecordType from "./DnsRecordType";
 
 export interface DnsRecordResponse {
@@ -13,4 +14,6 @@ export default interface DnsMonitorResponse {
   records: Array<DnsRecordResponse>;
   isDnssecValid?: boolean | undefined;
   isTimeout?: boolean | undefined;
+  probeAttempts?: Array<ProbeAttempt> | undefined;
+  totalAttempts?: number | undefined;
 }

package/Types/Monitor/DnssecMonitor/DnssecMonitorResponse.ts

@@ -1,3 +1,5 @@
+import ProbeAttempt from "../../Probe/ProbeAttempt";
+
 export interface DnssecKeyRecord {
   flags: number;
   algorithm: number;
@@ -66,4 +68,7 @@ export default interface DnssecMonitorResponse {
 
   // Overall chain validity (DNSKEY exists, DS exists, RRSIG valid, AD across resolvers)
   isChainValid: boolean;
+
+  probeAttempts?: Array<ProbeAttempt> | undefined;
+  totalAttempts?: number | undefined;
 }

package/Types/Monitor/DomainMonitor/DomainMonitorResponse.ts

@@ -1,3 +1,5 @@
+import ProbeAttempt from "../../Probe/ProbeAttempt";
+
 export default interface DomainMonitorResponse {
   isOnline: boolean;
   responseTimeInMs: number;
@@ -12,4 +14,6 @@ export default interface DomainMonitorResponse {
   dnssec?: string | undefined;
   domainStatus?: Array<string> | undefined;
   isTimeout?: boolean | undefined;
+  probeAttempts?: Array<ProbeAttempt> | undefined;
+  totalAttempts?: number | undefined;
 }

package/Types/Monitor/ExternalStatusPageMonitor/ExternalStatusPageMonitorResponse.ts

@@ -1,3 +1,5 @@
+import ProbeAttempt from "../../Probe/ProbeAttempt";
+
 export interface ExternalStatusPageComponentStatus {
   name: string;
   status: string;
@@ -13,4 +15,6 @@ export default interface ExternalStatusPageMonitorResponse {
   failureCause: string;
   rawBody?: string | undefined;
   isTimeout?: boolean | undefined;
+  probeAttempts?: Array<ProbeAttempt> | undefined;
+  totalAttempts?: number | undefined;
 }

package/Types/Monitor/SnmpMonitor/SnmpMonitorResponse.ts

@@ -1,3 +1,4 @@
+import ProbeAttempt from "../../Probe/ProbeAttempt";
 import SnmpDataType from "./SnmpDataType";
 
 export interface SnmpOidResponse {
@@ -13,4 +14,6 @@ export default interface SnmpMonitorResponse {
   failureCause: string;
   oidResponses: Array<SnmpOidResponse>;
   isTimeout?: boolean | undefined;
+  probeAttempts?: Array<ProbeAttempt> | undefined;
+  totalAttempts?: number | undefined;
 }