@oneuptime/common 10.0.39 → 10.0.41

package/Server/Services/DashboardService.ts

@@ -1,12 +1,27 @@
 import CreateBy from "../Types/Database/CreateBy";
 import { OnCreate } from "../Types/Database/Hooks";
+import CookieUtil from "../Utils/Cookie";
+import { ExpressRequest } from "../Utils/Express";
+import JSONWebToken from "../Utils/JsonWebToken";
+import logger from "../Utils/Logger";
 import DatabaseService from "./DatabaseService";
 import BadDataException from "../../Types/Exception/BadDataException";
+import NotAuthenticatedException from "../../Types/Exception/NotAuthenticatedException";
+import ForbiddenException from "../../Types/Exception/ForbiddenException";
+import MasterPasswordRequiredException from "../../Types/Exception/MasterPasswordRequiredException";
 import Model from "../../Models/DatabaseModels/Dashboard";
 import { IsBillingEnabled } from "../EnvironmentConfig";
 import { PlanType } from "../../Types/Billing/SubscriptionPlan";
 import DashboardViewConfigUtil from "../../Utils/Dashboard/DashboardViewConfig";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import ObjectID from "../../Types/ObjectID";
+import { JSONObject } from "../../Types/JSON";
+import IP from "../../Types/IP/IP";
+import {
+  DASHBOARD_MASTER_PASSWORD_COOKIE_IDENTIFIER,
+  DASHBOARD_MASTER_PASSWORD_REQUIRED_MESSAGE,
+} from "../../Types/Dashboard/MasterPassword";
+
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
@@ -40,12 +55,168 @@ export class Service extends DatabaseService<Model> {
       }
     }
 
-    // make sure dashboard config is empty.
-    createBy.data.dashboardViewConfig =
-      DashboardViewConfigUtil.createDefaultDashboardViewConfig();
+    // use default empty config only if no template config was provided.
+    if (
+      !createBy.data.dashboardViewConfig ||
+      !createBy.data.dashboardViewConfig.components ||
+      createBy.data.dashboardViewConfig.components.length === 0
+    ) {
+      createBy.data.dashboardViewConfig =
+        DashboardViewConfigUtil.createDefaultDashboardViewConfig();
+    }
 
     return Promise.resolve({ createBy, carryForward: null });
   }
+
+  public async hasReadAccess(data: {
+    dashboardId: ObjectID;
+    req: ExpressRequest;
+  }): Promise<{
+    hasReadAccess: boolean;
+    error?: NotAuthenticatedException | ForbiddenException;
+  }> {
+    const dashboardId: ObjectID = data.dashboardId;
+    const req: ExpressRequest = data.req;
+
+    try {
+      const dashboard: Model | null = await this.findOneById({
+        id: dashboardId,
+        props: {
+          isRoot: true,
+        },
+        select: {
+          _id: true,
+          isPublicDashboard: true,
+          ipWhitelist: true,
+          enableMasterPassword: true,
+          masterPassword: true,
+        },
+      });
+
+      // If dashboard is not public, deny access
+      if (dashboard && !dashboard.isPublicDashboard) {
+        return {
+          hasReadAccess: false,
+          error: new NotAuthenticatedException(
+            "This dashboard is not available.",
+          ),
+        };
+      }
+
+      if (dashboard?.ipWhitelist && dashboard.ipWhitelist.length > 0) {
+        const ipWhitelist: Array<string> = dashboard.ipWhitelist?.split("\n");
+
+        const ipAccessedFrom: string | undefined =
+          req.headers["x-forwarded-for"]?.toString() ||
+          req.headers["x-real-ip"]?.toString() ||
+          req.socket.remoteAddress ||
+          req.ip ||
+          req.ips[0];
+
+        if (!ipAccessedFrom) {
+          logger.error("IP address not found in request.");
+          return {
+            hasReadAccess: false,
+            error: new ForbiddenException(
+              "Unable to verify IP address for dashboard access.",
+            ),
+          };
+        }
+
+        const isIPWhitelisted: boolean = IP.isInWhitelist({
+          ips:
+            ipAccessedFrom?.split(",").map((i: string) => {
+              return i.trim();
+            }) || [],
+          whitelist: ipWhitelist,
+        });
+
+        if (!isIPWhitelisted) {
+          logger.error(
+            `IP address ${ipAccessedFrom} is not whitelisted for dashboard ${dashboardId.toString()}.`,
+          );
+
+          return {
+            hasReadAccess: false,
+            error: new ForbiddenException(
+              `Your IP address ${ipAccessedFrom} is blocked from accessing this dashboard.`,
+            ),
+          };
+        }
+      }
+
+      const shouldEnforceMasterPassword: boolean = Boolean(
+        dashboard &&
+          dashboard.isPublicDashboard &&
+          dashboard.enableMasterPassword &&
+          dashboard.masterPassword,
+      );
+
+      if (shouldEnforceMasterPassword) {
+        const hasValidMasterPassword: boolean =
+          this.hasValidMasterPasswordCookie({
+            req,
+            dashboardId,
+          });
+
+        if (hasValidMasterPassword) {
+          return {
+            hasReadAccess: true,
+          };
+        }
+
+        return {
+          hasReadAccess: false,
+          error: new MasterPasswordRequiredException(
+            DASHBOARD_MASTER_PASSWORD_REQUIRED_MESSAGE,
+          ),
+        };
+      }
+
+      // Public dashboard without master password - grant access
+      if (dashboard && dashboard.isPublicDashboard) {
+        return {
+          hasReadAccess: true,
+        };
+      }
+    } catch (err) {
+      logger.error(err);
+    }
+
+    return {
+      hasReadAccess: false,
+      error: new NotAuthenticatedException(
+        "You do not have access to this dashboard.",
+      ),
+    };
+  }
+
+  private hasValidMasterPasswordCookie(data: {
+    req: ExpressRequest;
+    dashboardId: ObjectID;
+  }): boolean {
+    const token: string | undefined = CookieUtil.getCookieFromExpressRequest(
+      data.req,
+      CookieUtil.getDashboardMasterPasswordKey(data.dashboardId),
+    );
+
+    if (!token) {
+      return false;
+    }
+
+    try {
+      const payload: JSONObject = JSONWebToken.decodeJsonPayload(token);
+
+      return (
+        payload["dashboardId"] === data.dashboardId.toString() &&
+        payload["type"] === DASHBOARD_MASTER_PASSWORD_COOKIE_IDENTIFIER
+      );
+    } catch (err) {
+      logger.error(err);
+    }
+
+    return false;
+  }
 }
 
 export default new Service();

package/Server/Services/IncidentService.ts

@@ -1039,6 +1039,7 @@ ${incident.remediationNotes || "No remediation notes provided."}
               " was created.",
           createdItem.createdStateLog,
           onCreate.createBy.props,
+          createdItem.declaredAt || undefined,
         );
       }
     } catch (error) {
@@ -1335,6 +1336,97 @@ ${incident.remediationNotes || "No remediation notes provided."}
           });
         }
 
+        // emit postmortem completion time metric when postmortemPostedAt is set
+        if (
+          Object.prototype.hasOwnProperty.call(
+            updatedIncidentData,
+            "postmortemPostedAt",
+          ) &&
+          updatedIncidentData["postmortemPostedAt"]
+        ) {
+          try {
+            const postmortemPostedAt: Date = updatedIncidentData[
+              "postmortemPostedAt"
+            ] as Date;
+
+            // find the resolved state timeline to calculate time from resolution to postmortem
+            const resolvedStateId: ObjectID =
+              await IncidentStateTimelineService.getResolvedStateIdForProject(
+                projectId,
+              );
+
+            const resolvedTimeline: IncidentStateTimeline | null =
+              await IncidentStateTimelineService.findOneBy({
+                query: {
+                  incidentId: incidentId,
+                  incidentStateId: resolvedStateId,
+                },
+                select: {
+                  startsAt: true,
+                },
+                sort: {
+                  startsAt: SortOrder.Descending,
+                },
+                props: {
+                  isRoot: true,
+                },
+              });
+
+            // only emit if the incident has been resolved
+            if (resolvedTimeline && resolvedTimeline.startsAt) {
+              const postmortemMetric: Metric = new Metric();
+              postmortemMetric.projectId = projectId;
+              postmortemMetric.serviceId = incidentId;
+              postmortemMetric.serviceType = ServiceType.Incident;
+              postmortemMetric.name =
+                IncidentMetricType.PostmortemCompletionTime;
+              postmortemMetric.value = OneUptimeDate.getDifferenceInSeconds(
+                postmortemPostedAt,
+                resolvedTimeline.startsAt,
+              );
+              postmortemMetric.attributes = {
+                incidentId: incidentId.toString(),
+                projectId: projectId.toString(),
+              };
+              postmortemMetric.attributeKeys = TelemetryUtil.getAttributeKeys(
+                postmortemMetric.attributes,
+              );
+              postmortemMetric.time = postmortemPostedAt;
+              postmortemMetric.timeUnixNano = OneUptimeDate.toUnixNano(
+                postmortemMetric.time,
+              );
+              postmortemMetric.metricPointType = MetricPointType.Sum;
+
+              await MetricService.create({
+                data: postmortemMetric,
+                props: {
+                  isRoot: true,
+                },
+              });
+
+              const postmortemMetricType: MetricType = new MetricType();
+              postmortemMetricType.name =
+                IncidentMetricType.PostmortemCompletionTime;
+              postmortemMetricType.description =
+                "Time from incident resolution to postmortem publication";
+              postmortemMetricType.unit = "seconds";
+
+              TelemetryUtil.indexMetricNameServiceNameMap({
+                metricNameServiceNameMap: {
+                  [postmortemMetricType.name]: postmortemMetricType,
+                },
+                projectId: projectId,
+              }).catch((err: Error) => {
+                logger.error(err);
+              });
+            }
+          } catch (metricError) {
+            logger.error(
+              `Failed to emit postmortem completion time metric: ${metricError}`,
+            );
+          }
+        }
+
         let shouldAddIncidentFeed: boolean = false;
         let feedInfoInMarkdown: string = `**[${incidentLabel}](${incidentLink.toString()}) was updated.**`;
 
@@ -1468,6 +1560,56 @@ ${incidentSeverity.name}
                 `SLA recalculation failed in IncidentService.onUpdateSuccess: ${slaError}`,
               );
             }
+
+            // emit severity change metric
+            try {
+              const severityChangeMetric: Metric = new Metric();
+              severityChangeMetric.projectId = projectId;
+              severityChangeMetric.serviceId = incidentId;
+              severityChangeMetric.serviceType = ServiceType.Incident;
+              severityChangeMetric.name = IncidentMetricType.SeverityChange;
+              severityChangeMetric.value = 1;
+              severityChangeMetric.attributes = {
+                incidentId: incidentId.toString(),
+                projectId: projectId.toString(),
+                newIncidentSeverityId: incidentSeverity._id?.toString() || "",
+                newIncidentSeverityName:
+                  incidentSeverity.name?.toString() || "",
+              };
+              severityChangeMetric.attributeKeys =
+                TelemetryUtil.getAttributeKeys(severityChangeMetric.attributes);
+              severityChangeMetric.time = OneUptimeDate.getCurrentDate();
+              severityChangeMetric.timeUnixNano = OneUptimeDate.toUnixNano(
+                severityChangeMetric.time,
+              );
+              severityChangeMetric.metricPointType = MetricPointType.Sum;
+
+              await MetricService.create({
+                data: severityChangeMetric,
+                props: {
+                  isRoot: true,
+                },
+              });
+
+              const severityChangeMetricType: MetricType = new MetricType();
+              severityChangeMetricType.name = IncidentMetricType.SeverityChange;
+              severityChangeMetricType.description =
+                "Count of incident severity changes";
+              severityChangeMetricType.unit = "";
+
+              TelemetryUtil.indexMetricNameServiceNameMap({
+                metricNameServiceNameMap: {
+                  [severityChangeMetricType.name]: severityChangeMetricType,
+                },
+                projectId: projectId,
+              }).catch((err: Error) => {
+                logger.error(err);
+              });
+            } catch (metricError) {
+              logger.error(
+                `Failed to emit severity change metric: ${metricError}`,
+              );
+            }
           }
         }
 
@@ -1693,6 +1835,7 @@ ${incidentSeverity.name}
   public async markMonitorsActiveForMonitoring(
     projectId: ObjectID,
     monitors: Array<Monitor>,
+    startsAt?: Date | undefined,
   ): Promise<void> {
     // resolve all the monitors.
 
@@ -1769,6 +1912,10 @@ ${incidentSeverity.name}
           monitorStatusTimeline.projectId = projectId!;
           monitorStatusTimeline.monitorStatusId = resolvedMonitorState.id!;
 
+          if (startsAt) {
+            monitorStatusTimeline.startsAt = startsAt;
+          }
+
           await MonitorStatusTimelineService.create({
             data: monitorStatusTimeline,
             props: {
@@ -1959,6 +2106,77 @@ ${incidentSeverity.name}
       throw new BadDataException("Incident Project ID not found");
     }
 
+    // fetch owner users and teams for metric attributes
+    const ownerUsers: Array<IncidentOwnerUser> =
+      await IncidentOwnerUserService.findBy({
+        query: {
+          incidentId: data.incidentId,
+        },
+        select: {
+          _id: true,
+          user: {
+            _id: true,
+            name: true,
+          },
+        },
+        props: {
+          isRoot: true,
+        },
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
+      });
+
+    const ownerTeams: Array<IncidentOwnerTeam> =
+      await IncidentOwnerTeamService.findBy({
+        query: {
+          incidentId: data.incidentId,
+        },
+        select: {
+          _id: true,
+          team: {
+            _id: true,
+            name: true,
+          },
+        },
+        props: {
+          isRoot: true,
+        },
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
+      });
+
+    const ownerUserIds: Array<string> = ownerUsers
+      .map((ownerUser: IncidentOwnerUser) => {
+        return ownerUser.user?._id?.toString();
+      })
+      .filter((id: string | undefined) => {
+        return Boolean(id);
+      }) as Array<string>;
+
+    const ownerUserNames: Array<string> = ownerUsers
+      .map((ownerUser: IncidentOwnerUser) => {
+        return ownerUser.user?.name?.toString();
+      })
+      .filter((name: string | undefined) => {
+        return Boolean(name);
+      }) as Array<string>;
+
+    const ownerTeamIds: Array<string> = ownerTeams
+      .map((ownerTeam: IncidentOwnerTeam) => {
+        return ownerTeam.team?._id?.toString();
+      })
+      .filter((id: string | undefined) => {
+        return Boolean(id);
+      }) as Array<string>;
+
+    const ownerTeamNames: Array<string> = ownerTeams
+      .map((ownerTeam: IncidentOwnerTeam) => {
+        return ownerTeam.team?.name?.toString();
+      })
+      .filter((name: string | undefined) => {
+        return Boolean(name);
+      }) as Array<string>;
+
     // get incident state timeline
 
     const incidentStateTimelines: Array<IncidentStateTimeline> =
@@ -1970,8 +2188,10 @@ ${incidentSeverity.name}
           projectId: true,
           incidentStateId: true,
           incidentState: {
+            name: true,
             isAcknowledgedState: true,
             isResolvedState: true,
+            isCreatedState: true,
           },
           startsAt: true,
           endsAt: true,
@@ -2013,14 +2233,8 @@ ${incidentSeverity.name}
 
     const metricTypesMap: Dictionary<MetricType> = {};
 
-    const incidentCountMetric: Metric = new Metric();
-
-    incidentCountMetric.projectId = incident.projectId;
-    incidentCountMetric.serviceId = incident.id!;
-    incidentCountMetric.serviceType = ServiceType.Incident;
-    incidentCountMetric.name = IncidentMetricType.IncidentCount;
-    incidentCountMetric.value = 1;
-    incidentCountMetric.attributes = {
+    // common attributes shared by all incident metrics
+    const baseMetricAttributes: JSONObject = {
       incidentId: data.incidentId.toString(),
       projectId: incident.projectId.toString(),
       monitorIds:
@@ -2033,7 +2247,20 @@ ${incidentSeverity.name}
         }) || [],
       incidentSeverityId: incident.incidentSeverity?._id?.toString(),
       incidentSeverityName: incident.incidentSeverity?.name?.toString(),
+      ownerUserIds: ownerUserIds,
+      ownerUserNames: ownerUserNames,
+      ownerTeamIds: ownerTeamIds,
+      ownerTeamNames: ownerTeamNames,
     };
+
+    const incidentCountMetric: Metric = new Metric();
+
+    incidentCountMetric.projectId = incident.projectId;
+    incidentCountMetric.serviceId = incident.id!;
+    incidentCountMetric.serviceType = ServiceType.Incident;
+    incidentCountMetric.name = IncidentMetricType.IncidentCount;
+    incidentCountMetric.value = 1;
+    incidentCountMetric.attributes = { ...baseMetricAttributes };
     incidentCountMetric.attributeKeys = TelemetryUtil.getAttributeKeys(
       incidentCountMetric.attributes,
     );
@@ -2080,20 +2307,7 @@ ${incidentSeverity.name}
           ackIncidentStateTimeline?.startsAt || OneUptimeDate.getCurrentDate(),
           incidentStartsAt,
         );
-        timeToAcknowledgeMetric.attributes = {
-          incidentId: data.incidentId.toString(),
-          projectId: incident.projectId.toString(),
-          monitorIds:
-            incident.monitors?.map((monitor: Monitor) => {
-              return monitor._id?.toString();
-            }) || [],
-          monitorNames:
-            incident.monitors?.map((monitor: Monitor) => {
-              return monitor.name?.toString();
-            }) || [],
-          incidentSeverityId: incident.incidentSeverity?._id?.toString(),
-          incidentSeverityName: incident.incidentSeverity?.name?.toString(),
-        };
+        timeToAcknowledgeMetric.attributes = { ...baseMetricAttributes };
         timeToAcknowledgeMetric.attributeKeys = TelemetryUtil.getAttributeKeys(
           timeToAcknowledgeMetric.attributes,
         );
@@ -2146,20 +2360,7 @@ ${incidentSeverity.name}
             OneUptimeDate.getCurrentDate(),
           incidentStartsAt,
         );
-        timeToResolveMetric.attributes = {
-          incidentId: data.incidentId.toString(),
-          projectId: incident.projectId.toString(),
-          monitorIds:
-            incident.monitors?.map((monitor: Monitor) => {
-              return monitor._id?.toString();
-            }) || [],
-          monitorNames:
-            incident.monitors?.map((monitor: Monitor) => {
-              return monitor.name?.toString();
-            }) || [],
-          incidentSeverityId: incident.incidentSeverity?._id?.toString(),
-          incidentSeverityName: incident.incidentSeverity?.name?.toString(),
-        };
+        timeToResolveMetric.attributes = { ...baseMetricAttributes };
         timeToResolveMetric.attributeKeys = TelemetryUtil.getAttributeKeys(
           timeToResolveMetric.attributes,
         );
@@ -2207,20 +2408,7 @@ ${incidentSeverity.name}
         incidentEndsAt,
         incidentStartsAt,
       );
-      incidentDurationMetric.attributes = {
-        incidentId: data.incidentId.toString(),
-        projectId: incident.projectId.toString(),
-        monitorIds:
-          incident.monitors?.map((monitor: Monitor) => {
-            return monitor._id?.toString();
-          }) || [],
-        monitorNames:
-          incident.monitors?.map((monitor: Monitor) => {
-            return monitor.name?.toString();
-          }) || [],
-        incidentSeverityId: incident.incidentSeverity?._id?.toString(),
-        incidentSeverityName: incident.incidentSeverity?.name?.toString(),
-      };
+      incidentDurationMetric.attributes = { ...baseMetricAttributes };
       incidentDurationMetric.attributeKeys = TelemetryUtil.getAttributeKeys(
         incidentDurationMetric.attributes,
       );
@@ -2247,6 +2435,63 @@ ${incidentSeverity.name}
       metricTypesMap[incidentDurationMetric.name] = metricType;
     }
 
+    // time-in-state metrics — emit one metric per state transition that has a completed duration
+    for (const timeline of incidentStateTimelines) {
+      if (!timeline.startsAt || !timeline.endsAt) {
+        continue;
+      }
+
+      const stateName: string =
+        timeline.incidentState?.name?.toString() || "Unknown";
+
+      const timeInStateMetric: Metric = new Metric();
+
+      timeInStateMetric.projectId = incident.projectId;
+      timeInStateMetric.serviceId = incident.id!;
+      timeInStateMetric.serviceType = ServiceType.Incident;
+      timeInStateMetric.name = IncidentMetricType.TimeInState;
+      timeInStateMetric.value = OneUptimeDate.getDifferenceInSeconds(
+        timeline.endsAt,
+        timeline.startsAt,
+      );
+      timeInStateMetric.attributes = {
+        ...baseMetricAttributes,
+        incidentStateName: stateName,
+        incidentStateId: timeline.incidentStateId?.toString(),
+        isCreatedState:
+          timeline.incidentState?.isCreatedState?.toString() || "false",
+        isAcknowledgedState:
+          timeline.incidentState?.isAcknowledgedState?.toString() || "false",
+        isResolvedState:
+          timeline.incidentState?.isResolvedState?.toString() || "false",
+      };
+      timeInStateMetric.attributeKeys = TelemetryUtil.getAttributeKeys(
+        timeInStateMetric.attributes,
+      );
+
+      timeInStateMetric.time = timeline.startsAt;
+      timeInStateMetric.timeUnixNano = OneUptimeDate.toUnixNano(
+        timeInStateMetric.time,
+      );
+      timeInStateMetric.metricPointType = MetricPointType.Sum;
+
+      itemsToSave.push(timeInStateMetric);
+    }
+
+    // add metric type for time-in-state to map (only once)
+    if (
+      incidentStateTimelines.some((t: IncidentStateTimeline) => {
+        return t.startsAt && t.endsAt;
+      })
+    ) {
+      const timeInStateMetricType: MetricType = new MetricType();
+      timeInStateMetricType.name = IncidentMetricType.TimeInState;
+      timeInStateMetricType.description =
+        "Time spent in each incident state (e.g. Created, Investigating, Acknowledged)";
+      timeInStateMetricType.unit = "seconds";
+      metricTypesMap[timeInStateMetricType.name] = timeInStateMetricType;
+    }
+
     await MetricService.createMany({
       items: itemsToSave,
       props: {

package/Server/Services/IncidentStateTimelineService.ts

@@ -497,6 +497,7 @@ ${createdItem.rootCause}`,
         await IncidentService.markMonitorsActiveForMonitoring(
           incident.projectId!,
           incident.monitors || [],
+          createdItem.startsAt || undefined,
         );
       }
     }

package/Server/Services/Index.ts

@@ -74,6 +74,8 @@ import AIAgentTaskPullRequestService from "./AIAgentTaskPullRequestService";
 import ProjectCallSMSConfigService from "./ProjectCallSMSConfigService";
 import ProjectService from "./ProjectService";
 import ProjectUserProfileService from "./ProjectUserProfileService";
+import ProfileService from "./ProfileService";
+import ProfileSampleService from "./ProfileSampleService";
 // Project SMTP Config.
 import ProjectSmtpConfigService from "./ProjectSmtpConfigService";
 import ProjectSsoService from "./ProjectSsoService";
@@ -105,6 +107,7 @@ import SpanService from "./SpanService";
 import StatusPageAnnouncementService from "./StatusPageAnnouncementService";
 import StatusPageAnnouncementTemplateService from "./StatusPageAnnouncementTemplateService";
 import StatusPageCustomFieldService from "./StatusPageCustomFieldService";
+import DashboardDomainService from "./DashboardDomainService";
 import StatusPageDomainService from "./StatusPageDomainService";
 import StatusPageFooterLinkService from "./StatusPageFooterLinkService";
 import StatusPageGroupService from "./StatusPageGroupService";
@@ -305,6 +308,7 @@ const services: Array<BaseService> = [
   StatusPageAnnouncementService,
   StatusPageAnnouncementTemplateService,
   StatusPageCustomFieldService,
+  DashboardDomainService,
   StatusPageDomainService,
   StatusPageFooterLinkService,
   StatusPageGroupService,
@@ -431,6 +435,8 @@ export const AnalyticsServices: Array<
   MetricService,
   ExceptionInstanceService,
   MonitorLogService,
+  ProfileService,
+  ProfileSampleService,
 ];
 
 export default services;

package/Server/Services/MonitorService.ts

@@ -1507,6 +1507,7 @@ ${createdItem.description?.trim() || "No description provided."}
     rootCause: string | undefined,
     statusChangeLog: JSONObject | undefined,
     props: DatabaseCommonInteractionProps,
+    startsAt?: Date | undefined,
   ): Promise<void> {
     for (const monitorId of monitorIds) {
       // get last monitor status timeline.
@@ -1552,6 +1553,10 @@ ${createdItem.description?.trim() || "No description provided."}
         statusTimeline.rootCause = rootCause;
       }
 
+      if (startsAt) {
+        statusTimeline.startsAt = startsAt;
+      }
+
       await MonitorStatusTimelineService.create({
         data: statusTimeline,
         props: props,