@oneuptime/common 8.0.5581 → 8.0.5583

package/Server/Services/ScheduledMaintenanceService.ts

@@ -193,6 +193,13 @@ export class Service extends DatabaseService<Model> {
         const statusPageName: string =
           statuspage.pageTitle || statuspage.name || "Status Page";
 
+        const scheduledEventDetailsUrl: string =
+          event.id && statusPageURL
+            ? URL.fromString(statusPageURL)
+                .addRoute(`/scheduled-events/${event.id.toString()}`)
+                .toString()
+            : statusPageURL;
+
         // Send email to Email subscribers.
 
         const resourcesAffected: string =
@@ -291,6 +298,7 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
                 vars: {
                   statusPageName: statusPageName,
                   statusPageUrl: statusPageURL,
+                  detailsUrl: scheduledEventDetailsUrl,
                   logoUrl:
                     statuspage.logoFileId && statusPageIdString
                       ? new URL(httpProtocol, host)
@@ -377,27 +385,60 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
         (updateBy.data.startsAt as Date) ||
         (scheduledMaintenance.startsAt! as Date);
 
-      const notificationSettings: Array<Recurring> =
-        (updateBy.data
-          .sendSubscriberNotificationsOnBeforeTheEvent as Array<Recurring>) ||
-        (scheduledMaintenance.sendSubscriberNotificationsOnBeforeTheEvent as Array<Recurring>);
+      let notificationSettings: Array<Recurring> | null = null;
+
+      const updatedNotificationSettings: Array<Recurring> | null | undefined =
+        updateBy.data.sendSubscriberNotificationsOnBeforeTheEvent as
+          | Array<Recurring>
+          | null
+          | undefined;
+
+      if (
+        updatedNotificationSettings !== null &&
+        updatedNotificationSettings !== undefined
+      ) {
+        notificationSettings = updatedNotificationSettings;
+      } else {
+        const existingNotificationSettings:
+          | Array<Recurring>
+          | null
+          | undefined =
+          scheduledMaintenance.sendSubscriberNotificationsOnBeforeTheEvent as
+            | Array<Recurring>
+            | null
+            | undefined;
+
+        if (
+          existingNotificationSettings !== null &&
+          existingNotificationSettings !== undefined
+        ) {
+          notificationSettings = existingNotificationSettings;
+        }
+      }
 
       logger.debug(
         `Using startsAt: ${startsAt} and notificationSettings: ${JSON.stringify(notificationSettings)}`,
       );
 
-      const nextTimeToNotifyBeforeTheEvent: Date | null =
-        this.getNextTimeToNotify({
-          eventScheduledDate: startsAt,
-          sendSubscriberNotifiationsOn: notificationSettings,
-        });
+      if (!notificationSettings || notificationSettings.length === 0) {
+        logger.debug(
+          "No subscriber notification schedule configured. Clearing nextSubscriberNotificationBeforeTheEventAt.",
+        );
+        updateBy.data.nextSubscriberNotificationBeforeTheEventAt = null;
+      } else {
+        const nextTimeToNotifyBeforeTheEvent: Date | null =
+          this.getNextTimeToNotify({
+            eventScheduledDate: startsAt,
+            sendSubscriberNotifiationsOn: notificationSettings,
+          });
 
-      updateBy.data.nextSubscriberNotificationBeforeTheEventAt =
-        nextTimeToNotifyBeforeTheEvent;
+        updateBy.data.nextSubscriberNotificationBeforeTheEventAt =
+          nextTimeToNotifyBeforeTheEvent;
 
-      logger.debug(
-        `nextSubscriberNotificationBeforeTheEventAt set to: ${nextTimeToNotifyBeforeTheEvent}`,
-      );
+        logger.debug(
+          `nextSubscriberNotificationBeforeTheEventAt set to: ${nextTimeToNotifyBeforeTheEvent}`,
+        );
+      }
     }
 
     // Set notification status based on shouldStatusPageSubscribersBeNotifiedOnEventCreated if it's being updated
@@ -475,7 +516,7 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
 
   public getNextTimeToNotify(data: {
     eventScheduledDate: Date;
-    sendSubscriberNotifiationsOn: Array<Recurring>;
+    sendSubscriberNotifiationsOn?: Array<Recurring> | null | undefined;
   }): Date | null {
     let recurringDate: Date | null = null;
 
@@ -486,7 +527,23 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
       `Calculating next time to notify for event scheduled date: ${data.eventScheduledDate}`,
     );
 
-    for (const recurringItem of data.sendSubscriberNotifiationsOn) {
+    const notificationSchedules: Array<Recurring> = Array.isArray(
+      data.sendSubscriberNotifiationsOn,
+    )
+      ? (data.sendSubscriberNotifiationsOn as Array<Recurring>)
+      : [];
+
+    if (notificationSchedules.length === 0) {
+      logger.debug(
+        "No sendSubscriberNotifiationsOn entries. Returning null for next notification time.",
+      );
+      return null;
+    }
+
+    for (const recurringItem of notificationSchedules) {
+      if (!recurringItem) {
+        continue;
+      }
       const notificationDate: Date = Recurring.getNextDateInterval(
         data.eventScheduledDate,
         recurringItem,

package/Server/Services/StatusPageService.ts

@@ -778,6 +778,7 @@ export class Service extends DatabaseService<StatusPage> {
             subscriberEmailNotificationFooterText:
               Service.getSubscriberEmailFooterText(statuspage),
             statusPageUrl: statusPageURL,
+            detailsUrl: statusPageURL,
             hasResources: report.totalResources > 0 ? "true" : "false",
             report: report as any,
             logoUrl:

package/Server/Utils/Monitor/MonitorCriteriaEvaluator.ts

@@ -11,6 +11,8 @@ import MetricMonitorCriteria from "./Criteria/MetricMonitorCriteria";
 import TraceMonitorCriteria from "./Criteria/TraceMonitorCriteria";
 import ExceptionMonitorCriteria from "./Criteria/ExceptionMonitorCriteria";
 import MonitorCriteriaMessageBuilder from "./MonitorCriteriaMessageBuilder";
+import MonitorCriteriaDataExtractor from "./MonitorCriteriaDataExtractor";
+import MonitorCriteriaMessageFormatter from "./MonitorCriteriaMessageFormatter";
 import DataToProcess from "./DataToProcess";
 import Monitor from "../../../Models/DatabaseModels/Monitor";
 import MonitorCriteria from "../../../Types/Monitor/MonitorCriteria";
@@ -98,6 +100,19 @@ export default class MonitorCriteriaEvaluator {
 **Filter Conditions Met**: ${rootCause}
 `;
 
+        const contextBlock: string | null =
+          MonitorCriteriaEvaluator.buildRootCauseContext({
+            dataToProcess: input.dataToProcess,
+            monitorStep: input.monitorStep,
+            monitor: input.monitor,
+          });
+
+        if (contextBlock) {
+          input.probeApiIngestResponse.rootCause += `
+${contextBlock}
+`;
+        }
+
         if ((input.dataToProcess as ProbeMonitorResponse).failureCause) {
           input.probeApiIngestResponse.rootCause += `
 **Cause**: ${(input.dataToProcess as ProbeMonitorResponse).failureCause || ""}
@@ -449,4 +464,160 @@ export default class MonitorCriteriaEvaluator {
 
     return null;
   }
+
+  private static buildRootCauseContext(input: {
+    dataToProcess: DataToProcess;
+    monitorStep: MonitorStep;
+    monitor: Monitor;
+  }): string | null {
+    const requestDetails: Array<string> = [];
+    const responseDetails: Array<string> = [];
+
+    const probeResponse: ProbeMonitorResponse | null =
+      MonitorCriteriaDataExtractor.getProbeMonitorResponse(input.dataToProcess);
+
+    const destination: string | null =
+      MonitorCriteriaEvaluator.getMonitorDestinationString({
+        monitorStep: input.monitorStep,
+        probeResponse: probeResponse,
+      });
+
+    if (destination) {
+      requestDetails.push(`- Destination: ${destination}`);
+    }
+
+    const port: string | null = MonitorCriteriaEvaluator.getMonitorPortString({
+      monitorStep: input.monitorStep,
+      probeResponse: probeResponse,
+    });
+
+    if (port) {
+      requestDetails.push(`- Destination Port: ${port}`);
+    }
+
+    const requestMethod: string | null =
+      MonitorCriteriaEvaluator.getRequestMethodString({
+        monitor: input.monitor,
+        monitorStep: input.monitorStep,
+      });
+
+    if (requestMethod) {
+      requestDetails.push(`- Request Method: ${requestMethod}`);
+    }
+
+    if (probeResponse?.responseCode !== undefined) {
+      responseDetails.push(
+        `- Response Status Code: ${probeResponse.responseCode}`,
+      );
+    }
+
+    const responseTime: string | null =
+      MonitorCriteriaEvaluator.formatMilliseconds(
+        probeResponse?.responseTimeInMs,
+      );
+
+    if (responseTime) {
+      responseDetails.push(`- Response Time: ${responseTime}`);
+    }
+
+    if (probeResponse?.isTimeout !== undefined) {
+      responseDetails.push(
+        `- Timed Out: ${probeResponse.isTimeout ? "Yes" : "No"}`,
+      );
+    }
+
+    const sections: Array<string> = [];
+
+    if (requestDetails.length > 0) {
+      sections.push(`**Request Details**\n${requestDetails.join("\n")}`);
+    }
+
+    if (responseDetails.length > 0) {
+      sections.push(`\n\n**Response Snapshot**\n${responseDetails.join("\n")}`);
+    }
+
+    if (!sections.length) {
+      return null;
+    }
+
+    return sections.join("\n");
+  }
+
+  private static getMonitorDestinationString(input: {
+    monitorStep: MonitorStep;
+    probeResponse: ProbeMonitorResponse | null;
+  }): string | null {
+    if (input.probeResponse?.monitorDestination) {
+      return MonitorCriteriaEvaluator.stringifyValue(
+        input.probeResponse.monitorDestination,
+      );
+    }
+
+    if (input.monitorStep.data?.monitorDestination) {
+      return MonitorCriteriaEvaluator.stringifyValue(
+        input.monitorStep.data.monitorDestination,
+      );
+    }
+
+    return null;
+  }
+
+  private static getMonitorPortString(input: {
+    monitorStep: MonitorStep;
+    probeResponse: ProbeMonitorResponse | null;
+  }): string | null {
+    if (input.probeResponse?.monitorDestinationPort) {
+      return MonitorCriteriaEvaluator.stringifyValue(
+        input.probeResponse.monitorDestinationPort,
+      );
+    }
+
+    if (input.monitorStep.data?.monitorDestinationPort) {
+      return MonitorCriteriaEvaluator.stringifyValue(
+        input.monitorStep.data.monitorDestinationPort,
+      );
+    }
+
+    return null;
+  }
+
+  private static getRequestMethodString(input: {
+    monitor: Monitor;
+    monitorStep: MonitorStep;
+  }): string | null {
+    if (
+      input.monitor.monitorType === MonitorType.API &&
+      input.monitorStep.data
+    ) {
+      return `${input.monitorStep.data.requestType}`;
+    }
+
+    return null;
+  }
+
+  private static formatMilliseconds(value?: number): string | null {
+    if (value === undefined || value === null || isNaN(value)) {
+      return null;
+    }
+
+    const formatted: string | null =
+      MonitorCriteriaMessageFormatter.formatNumber(value, {
+        maximumFractionDigits: value < 100 ? 2 : value < 1000 ? 1 : 0,
+      });
+
+    return `${formatted ?? value} ms`;
+  }
+
+  private static stringifyValue(value: unknown): string | null {
+    if (value === null || value === undefined) {
+      return null;
+    }
+
+    try {
+      return String(value).trim();
+    } catch (err) {
+      logger.error(err);
+      return null;
+    }
+  }
 }

package/Server/Utils/OpenAPI.ts

@@ -669,32 +669,42 @@ export default class OpenAPIUtil {
     modelType: new () => DatabaseBaseModel,
     model: DatabaseBaseModel,
   ): void {
-    // Check if model has create permissions and should not exclude API generation
-    if (!this.shouldExcludeApiForPermissions(model.createRecordPermissions)) {
+    const canCreate: boolean = !this.shouldExcludeApiForPermissions(
+      model.createRecordPermissions,
+    );
+    const canRead: boolean = !this.shouldExcludeApiForPermissions(
+      model.readRecordPermissions,
+    );
+    const canUpdate: boolean = !this.shouldExcludeApiForPermissions(
+      model.updateRecordPermissions,
+    );
+    const canDelete: boolean = !this.shouldExcludeApiForPermissions(
+      model.deleteRecordPermissions,
+    );
+
+    if (canCreate) {
       const createSchema: ModelSchemaType = ModelSchema.getCreateModelSchema({
         modelType,
       });
       registry.register(`${tableName}CreateSchema`, createSchema);
     }
 
-    // Check if model has read permissions and should not exclude API generation
-    if (!this.shouldExcludeApiForPermissions(model.readRecordPermissions)) {
+    // Register read schema whenever any operation might return it (create/update/read)
+    if (canRead || canCreate || canUpdate) {
       const readSchema: ModelSchemaType = ModelSchema.getReadModelSchema({
         modelType,
       });
       registry.register(`${tableName}ReadSchema`, readSchema);
     }
 
-    // Check if model has update permissions and should not exclude API generation
-    if (!this.shouldExcludeApiForPermissions(model.updateRecordPermissions)) {
+    if (canUpdate) {
       const updateSchema: ModelSchemaType = ModelSchema.getUpdateModelSchema({
         modelType,
       });
       registry.register(`${tableName}UpdateSchema`, updateSchema);
     }
 
-    // Check if model has delete permissions and should not exclude API generation
-    if (!this.shouldExcludeApiForPermissions(model.deleteRecordPermissions)) {
+    if (canDelete) {
       const deleteSchema: ModelSchemaType = ModelSchema.getDeleteModelSchema({
         modelType,
       });
@@ -766,8 +776,20 @@ export default class OpenAPIUtil {
     modelType: new () => AnalyticsBaseModel,
     model: AnalyticsBaseModel,
   ): void {
-    // Check if model has create permissions and should not exclude API generation
-    if (!this.shouldExcludeApiForPermissions(model.getCreatePermissions())) {
+    const canCreate: boolean = !this.shouldExcludeApiForPermissions(
+      model.getCreatePermissions(),
+    );
+    const canRead: boolean = !this.shouldExcludeApiForPermissions(
+      model.getReadPermissions(),
+    );
+    const canUpdate: boolean = !this.shouldExcludeApiForPermissions(
+      model.getUpdatePermissions(),
+    );
+    const canDelete: boolean = !this.shouldExcludeApiForPermissions(
+      model.getDeletePermissions(),
+    );
+
+    if (canCreate) {
       const createSchema: AnalyticsModelSchemaType =
         AnalyticsModelSchema.getCreateModelSchema({
           modelType,
@@ -775,8 +797,7 @@ export default class OpenAPIUtil {
       registry.register(`${tableName}CreateSchema`, createSchema);
     }
 
-    // Check if model has read permissions and should not exclude API generation
-    if (!this.shouldExcludeApiForPermissions(model.getReadPermissions())) {
+    if (canRead || canCreate || canUpdate) {
       const readSchema: AnalyticsModelSchemaType =
         AnalyticsModelSchema.getModelSchema({
           modelType,
@@ -784,8 +805,7 @@ export default class OpenAPIUtil {
       registry.register(`${tableName}ReadSchema`, readSchema);
     }
 
-    // Check if model has update permissions and should not exclude API generation
-    if (!this.shouldExcludeApiForPermissions(model.getUpdatePermissions())) {
+    if (canUpdate) {
       const updateSchema: AnalyticsModelSchemaType =
         AnalyticsModelSchema.getCreateModelSchema({
           modelType,
@@ -793,8 +813,7 @@ export default class OpenAPIUtil {
       registry.register(`${tableName}UpdateSchema`, updateSchema);
     }
 
-    // Check if model has delete permissions and should not exclude API generation
-    if (!this.shouldExcludeApiForPermissions(model.getDeletePermissions())) {
+    if (canDelete) {
       const deleteSchema: AnalyticsModelSchemaType =
         AnalyticsModelSchema.getModelSchema({
           modelType,

package/Types/Permission.ts

@@ -922,28 +922,28 @@ export class PermissionHelper {
         title: "Create Dashboard",
         description: "This permission can create Dashboards of this project",
         isAssignableToTenant: true,
-        isAccessControlPermission: false,
+        isAccessControlPermission: true,
       },
       {
         permission: Permission.DeleteDashboard,
         title: "Delete Dashboard",
         description: "This permission can delete Dashboard of this project.",
         isAssignableToTenant: true,
-        isAccessControlPermission: false,
+        isAccessControlPermission: true,
       },
       {
         permission: Permission.EditDashboard,
         title: "Edit Dashboard",
         description: "This permission can edit Dashboards of this project.",
         isAssignableToTenant: true,
-        isAccessControlPermission: false,
+        isAccessControlPermission: true,
       },
       {
         permission: Permission.ReadDashboard,
         title: "Read Dashboard",
         description: "This permission can read Dashboards of this project.",
         isAssignableToTenant: true,
-        isAccessControlPermission: false,
+        isAccessControlPermission: true,
       },
 
       // Table view permissions

package/build/dist/Server/Services/ScheduledMaintenanceService.js

@@ -139,6 +139,11 @@ export class Service extends DatabaseService {
                 });
                 const statusPageURL = await StatusPageService.getStatusPageURL(statuspage.id);
                 const statusPageName = statuspage.pageTitle || statuspage.name || "Status Page";
+                const scheduledEventDetailsUrl = event.id && statusPageURL
+                    ? URL.fromString(statusPageURL)
+                        .addRoute(`/scheduled-events/${event.id.toString()}`)
+                        .toString()
+                    : statusPageURL;
                 // Send email to Email subscribers.
                 const resourcesAffected = ((_f = statusPageToResources[statuspage._id]) === null || _f === void 0 ? void 0 : _f.map((r) => {
                     return r.displayName;
@@ -211,6 +216,7 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
                             vars: {
                                 statusPageName: statusPageName,
                                 statusPageUrl: statusPageURL,
+                                detailsUrl: scheduledEventDetailsUrl,
                                 logoUrl: statuspage.logoFileId && statusPageIdString
                                     ? new URL(httpProtocol, host)
                                         .addRoute(StatusPageApiRoute)
@@ -267,17 +273,33 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
             }
             const startsAt = updateBy.data.startsAt ||
                 scheduledMaintenance.startsAt;
-            const notificationSettings = updateBy.data
-                .sendSubscriberNotificationsOnBeforeTheEvent ||
-                scheduledMaintenance.sendSubscriberNotificationsOnBeforeTheEvent;
+            let notificationSettings = null;
+            const updatedNotificationSettings = updateBy.data.sendSubscriberNotificationsOnBeforeTheEvent;
+            if (updatedNotificationSettings !== null &&
+                updatedNotificationSettings !== undefined) {
+                notificationSettings = updatedNotificationSettings;
+            }
+            else {
+                const existingNotificationSettings = scheduledMaintenance.sendSubscriberNotificationsOnBeforeTheEvent;
+                if (existingNotificationSettings !== null &&
+                    existingNotificationSettings !== undefined) {
+                    notificationSettings = existingNotificationSettings;
+                }
+            }
             logger.debug(`Using startsAt: ${startsAt} and notificationSettings: ${JSON.stringify(notificationSettings)}`);
-            const nextTimeToNotifyBeforeTheEvent = this.getNextTimeToNotify({
-                eventScheduledDate: startsAt,
-                sendSubscriberNotifiationsOn: notificationSettings,
-            });
-            updateBy.data.nextSubscriberNotificationBeforeTheEventAt =
-                nextTimeToNotifyBeforeTheEvent;
-            logger.debug(`nextSubscriberNotificationBeforeTheEventAt set to: ${nextTimeToNotifyBeforeTheEvent}`);
+            if (!notificationSettings || notificationSettings.length === 0) {
+                logger.debug("No subscriber notification schedule configured. Clearing nextSubscriberNotificationBeforeTheEventAt.");
+                updateBy.data.nextSubscriberNotificationBeforeTheEventAt = null;
+            }
+            else {
+                const nextTimeToNotifyBeforeTheEvent = this.getNextTimeToNotify({
+                    eventScheduledDate: startsAt,
+                    sendSubscriberNotifiationsOn: notificationSettings,
+                });
+                updateBy.data.nextSubscriberNotificationBeforeTheEventAt =
+                    nextTimeToNotifyBeforeTheEvent;
+                logger.debug(`nextSubscriberNotificationBeforeTheEventAt set to: ${nextTimeToNotifyBeforeTheEvent}`);
+            }
         }
         // Set notification status based on shouldStatusPageSubscribersBeNotifiedOnEventCreated if it's being updated
         if (updateBy.data.shouldStatusPageSubscribersBeNotifiedOnEventCreated !==
@@ -337,7 +359,17 @@ ${resourcesAffected ? `**Resources Affected:** ${resourcesAffected}` : ""}
         logger.debug(`getNextTimeToNotify: `);
         logger.debug(data);
         logger.debug(`Calculating next time to notify for event scheduled date: ${data.eventScheduledDate}`);
-        for (const recurringItem of data.sendSubscriberNotifiationsOn) {
+        const notificationSchedules = Array.isArray(data.sendSubscriberNotifiationsOn)
+            ? data.sendSubscriberNotifiationsOn
+            : [];
+        if (notificationSchedules.length === 0) {
+            logger.debug("No sendSubscriberNotifiationsOn entries. Returning null for next notification time.");
+            return null;
+        }
+        for (const recurringItem of notificationSchedules) {
+            if (!recurringItem) {
+                continue;
+            }
             const notificationDate = Recurring.getNextDateInterval(data.eventScheduledDate, recurringItem, true);
             logger.debug(`Notification date calculated: ${notificationDate} for recurring item: ${recurringItem}`);
             // if this date is in the future. set it to recurring date.