@oneuptime/common 9.2.26 → 9.3.0

package/Server/Utils/Monitor/MonitorResource.ts

@@ -40,6 +40,17 @@ import CaptureSpan from "../Telemetry/CaptureSpan";
 import ExceptionMessages from "../../../Types/Exception/ExceptionMessages";
 import MonitorEvaluationSummary from "../../../Types/Monitor/MonitorEvaluationSummary";
 import MonitorStatusService from "../../Services/MonitorStatusService";
+import { ProbeConnectionStatus } from "../../../Models/DatabaseModels/Probe";
+import { LIMIT_PER_PROJECT } from "../../../Types/Database/LimitMax";
+
+interface ProbeAgreementResult {
+  hasAgreement: boolean;
+  agreementCount: number;
+  requiredCount: number;
+  totalActiveProbes: number;
+  agreedCriteriaId: string | null;
+  agreedRootCause: string | null;
+}
 
 export default class MonitorResourceUtil {
   @CaptureSpan()
@@ -125,6 +136,7 @@ export default class MonitorResourceUtil {
         currentMonitorStatusId: true,
         _id: true,
         name: true,
+        minimumProbeAgreement: true,
       },
       props: {
         isRoot: true,
@@ -500,6 +512,62 @@ export default class MonitorResourceUtil {
       evaluationSummary: evaluationSummary,
     });
 
+    // Check probe agreement for probe-based monitors
+    if (
+      monitor.monitorType &&
+      MonitorTypeHelper.isProbableMonitor(monitor.monitorType)
+    ) {
+      const probeAgreementResult: ProbeAgreementResult =
+        await MonitorResourceUtil.checkProbeAgreement({
+          monitor: monitor,
+          monitorStep: monitorStep,
+          currentCriteriaMetId: response.criteriaMetId || null,
+          currentRootCause: response.rootCause || null,
+        });
+
+      // Add probe agreement event to evaluation summary
+      evaluationSummary.events.push({
+        type: "probe-agreement",
+        title: "Probe Agreement Check",
+        message: probeAgreementResult.hasAgreement
+          ? `Probe agreement reached: ${probeAgreementResult.agreementCount}/${probeAgreementResult.requiredCount} probes agree (${probeAgreementResult.totalActiveProbes} active probes total).`
+          : `Probe agreement not reached: ${probeAgreementResult.agreementCount}/${probeAgreementResult.requiredCount} probes agree (${probeAgreementResult.totalActiveProbes} active probes total). Skipping status change.`,
+        at: OneUptimeDate.getCurrentDate(),
+      });
+
+      if (!probeAgreementResult.hasAgreement) {
+        logger.debug(
+          `${dataToProcess.monitorId.toString()} - Probe agreement not met. ${probeAgreementResult.agreementCount}/${probeAgreementResult.requiredCount} probes agree. Skipping status change.`,
+        );
+
+        // Release lock and return early - no status change
+        if (mutex) {
+          try {
+            await Semaphore.release(mutex);
+          } catch (err) {
+            logger.error(err);
+          }
+        }
+
+        await persistLatestMonitorPayload();
+
+        MonitorLogUtil.saveMonitorLog({
+          monitorId: monitor.id!,
+          projectId: monitor.projectId!,
+          dataToProcess: dataToProcess,
+        });
+
+        response.evaluationSummary = evaluationSummary;
+        return response;
+      }
+
+      // Use the agreed criteria result
+      response.criteriaMetId = probeAgreementResult.agreedCriteriaId
+        ? probeAgreementResult.agreedCriteriaId
+        : undefined;
+      response.rootCause = probeAgreementResult.agreedRootCause;
+    }
+
     if (response.criteriaMetId && response.rootCause) {
       logger.debug(
         `${dataToProcess.monitorId.toString()} - Criteria met: ${
@@ -735,4 +803,164 @@ export default class MonitorResourceUtil {
 
     return response;
   }
+
+  @CaptureSpan()
+  private static async checkProbeAgreement(input: {
+    monitor: Monitor;
+    monitorStep: MonitorStep;
+    currentCriteriaMetId: string | null;
+    currentRootCause: string | null;
+  }): Promise<ProbeAgreementResult> {
+    const { monitor, monitorStep, currentCriteriaMetId, currentRootCause } =
+      input;
+
+    /*
+     * If minimumProbeAgreement is not set, all probes must agree
+     * Get all MonitorProbes for this monitor with their probe connection status
+     */
+    const monitorProbes: Array<MonitorProbe> = await MonitorProbeService.findBy(
+      {
+        query: {
+          monitorId: monitor.id!,
+        },
+        select: {
+          probeId: true,
+          isEnabled: true,
+          lastMonitoringLog: true,
+          probe: {
+            connectionStatus: true,
+          },
+        },
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      },
+    );
+
+    // Filter to only active probes (enabled AND connected)
+    const activeProbes: Array<MonitorProbe> = monitorProbes.filter(
+      (mp: MonitorProbe) => {
+        return (
+          mp.isEnabled &&
+          mp.probe?.connectionStatus === ProbeConnectionStatus.Connected
+        );
+      },
+    );
+
+    // If no active probes, treat as agreement met (nothing to compare)
+    if (activeProbes.length === 0) {
+      logger.debug(
+        `${monitor.id?.toString()} - No active probes found. Treating as agreement met.`,
+      );
+      return {
+        hasAgreement: true,
+        agreementCount: 0,
+        requiredCount: 0,
+        totalActiveProbes: 0,
+        agreedCriteriaId: currentCriteriaMetId,
+        agreedRootCause: currentRootCause,
+      };
+    }
+
+    // Determine required count for agreement
+    const requiredCount: number =
+      monitor.minimumProbeAgreement ?? activeProbes.length;
+    // Effective threshold cannot exceed number of active probes
+    const effectiveThreshold: number = Math.min(
+      requiredCount,
+      activeProbes.length,
+    );
+
+    /*
+     * Count how many probes agree on each criteria result
+     * Key: criteriaId or "none" for no criteria met
+     * Value: { count, rootCause }
+     */
+    const criteriaAgreements: Map<
+      string,
+      { count: number; rootCause: string | null }
+    > = new Map();
+
+    const stepId: string = monitorStep.id.toString();
+
+    for (const monitorProbe of activeProbes) {
+      const probeResponse: ProbeMonitorResponse | undefined =
+        monitorProbe.lastMonitoringLog?.[stepId];
+
+      if (!probeResponse) {
+        // No response yet for this step from this probe - skip
+        logger.debug(
+          `${monitor.id?.toString()} - Probe ${monitorProbe.probeId?.toString()} has no response for step ${stepId}. Skipping.`,
+        );
+        continue;
+      }
+
+      // Evaluate this probe's response against criteria
+      const tempResponse: ProbeApiIngestResponse = {
+        monitorId: monitor.id!,
+        criteriaMetId: undefined,
+        rootCause: null,
+      };
+
+      const tempEvaluationSummary: MonitorEvaluationSummary = {
+        evaluatedAt: OneUptimeDate.getCurrentDate(),
+        criteriaResults: [],
+        events: [],
+      };
+
+      const evaluatedResponse: ProbeApiIngestResponse =
+        await MonitorCriteriaEvaluator.processMonitorStep({
+          dataToProcess: probeResponse as DataToProcess,
+          monitorStep: monitorStep,
+          monitor: monitor,
+          probeApiIngestResponse: tempResponse,
+          evaluationSummary: tempEvaluationSummary,
+        });
+
+      // Record the result
+      const criteriaKey: string = evaluatedResponse.criteriaMetId || "none";
+      const existing: { count: number; rootCause: string | null } | undefined =
+        criteriaAgreements.get(criteriaKey);
+
+      if (existing) {
+        existing.count += 1;
+      } else {
+        criteriaAgreements.set(criteriaKey, {
+          count: 1,
+          rootCause: evaluatedResponse.rootCause,
+        });
+      }
+    }
+
+    // Find the criteria with the most agreement
+    let maxCount: number = 0;
+    let winningCriteriaId: string | null = null;
+    let winningRootCause: string | null = null;
+
+    for (const [criteriaId, data] of criteriaAgreements) {
+      if (data.count > maxCount) {
+        maxCount = data.count;
+        winningCriteriaId = criteriaId === "none" ? null : criteriaId;
+        winningRootCause = data.rootCause;
+      }
+    }
+
+    // Check if the winning criteria has reached the agreement threshold
+    const hasAgreement: boolean = maxCount >= effectiveThreshold;
+
+    logger.debug(
+      `${monitor.id?.toString()} - Probe agreement check: ${maxCount}/${effectiveThreshold} probes agree on criteria "${winningCriteriaId || "none"}". Agreement ${hasAgreement ? "reached" : "not reached"}.`,
+    );
+
+    return {
+      hasAgreement,
+      agreementCount: maxCount,
+      requiredCount: effectiveThreshold,
+      totalActiveProbes: activeProbes.length,
+      agreedCriteriaId: hasAgreement ? winningCriteriaId : null,
+      agreedRootCause: hasAgreement ? winningRootCause : null,
+    };
+  }
 }

package/Server/Utils/PushNotificationUtil.ts

@@ -327,4 +327,33 @@ export default class PushNotificationUtil {
 
     return PushNotificationUtil.applyDefaults(notification);
   }
+
+  public static createAIAgentStatusChangedNotification(params: {
+    aiAgentName: string;
+    projectName: string;
+    connectionStatus: string;
+    clickAction?: string;
+  }): PushNotificationMessage {
+    const { aiAgentName, projectName, connectionStatus, clickAction } = params;
+    const notification: Partial<PushNotificationMessage> = {
+      title: `AI Agent ${connectionStatus}: ${aiAgentName}`,
+      body: `AI Agent ${aiAgentName} is ${connectionStatus} in ${projectName}. Click to view details.`,
+      tag: "ai-agent-status-changed",
+      requireInteraction: true,
+      data: {
+        type: "ai-agent-status-changed",
+        aiAgentName: aiAgentName,
+        projectName: projectName,
+        connectionStatus: connectionStatus,
+      },
+    };
+
+    if (clickAction) {
+      notification.clickAction = clickAction;
+      notification.url = clickAction;
+      notification.data!["url"] = clickAction;
+    }
+
+    return PushNotificationUtil.applyDefaults(notification);
+  }
 }

package/Server/Utils/WhatsAppTemplateUtil.ts

@@ -42,6 +42,8 @@ const templateDashboardLinkVariableMap: Partial<
   [WhatsAppTemplateIds.StatusPageOwnerAddedNotification]: "status_page_link",
   [WhatsAppTemplateIds.ProbeStatusChangedOwnerNotification]: "probe_link",
   [WhatsAppTemplateIds.ProbeOwnerAddedNotification]: "probe_link",
+  [WhatsAppTemplateIds.AIAgentStatusChangedOwnerNotification]: "ai_agent_link",
+  [WhatsAppTemplateIds.AIAgentOwnerAddedNotification]: "ai_agent_link",
   [WhatsAppTemplateIds.OnCallUserIsOnRosterNotification]: "schedule_link",
   [WhatsAppTemplateIds.OnCallUserIsNextNotification]: "schedule_link",
   [WhatsAppTemplateIds.OnCallUserNoLongerActiveNotification]: "schedule_link",
@@ -98,6 +100,10 @@ const templateIdByEventType: Record<
     WhatsAppTemplateIds.ProbeStatusChangedOwnerNotification,
   [NotificationSettingEventType.SEND_PROBE_OWNER_ADDED_NOTIFICATION]:
     WhatsAppTemplateIds.ProbeOwnerAddedNotification,
+  [NotificationSettingEventType.SEND_AI_AGENT_STATUS_CHANGED_OWNER_NOTIFICATION]:
+    WhatsAppTemplateIds.AIAgentStatusChangedOwnerNotification,
+  [NotificationSettingEventType.SEND_AI_AGENT_OWNER_ADDED_NOTIFICATION]:
+    WhatsAppTemplateIds.AIAgentOwnerAddedNotification,
   [NotificationSettingEventType.SEND_WHEN_USER_IS_ON_CALL_ROSTER]:
     WhatsAppTemplateIds.OnCallUserIsOnRosterNotification,
   [NotificationSettingEventType.SEND_WHEN_USER_IS_NEXT_ON_CALL_ROSTER]:

package/Tests/UI/Components/Badge.test.tsx

@@ -15,27 +15,27 @@ describe("Badge", () => {
     const badge: HTMLElement = screen.getByTestId("badge");
     expect(badge).toBeInTheDocument();
     const testId: HTMLElement = screen.getByText(1);
-    expect(testId).toHaveClass("text-emerald-600");
+    expect(testId).toHaveClass("text-emerald-700");
   });
   test("it should show success when badgetype is equal to success", () => {
     render(<Badge badgeCount={1} badgeType={BadgeType.SUCCESS} />);
     const testId: HTMLElement = screen.getByText(1);
-    expect(testId).toHaveClass("text-emerald-600");
+    expect(testId).toHaveClass("text-emerald-700");
   });
   test("it should show danger when badgetype is equal to danger", () => {
     render(<Badge badgeCount={1} badgeType={BadgeType.DANGER} />);
     const testId: HTMLElement = screen.getByText(1);
-    expect(testId).toHaveClass("text-red-600");
+    expect(testId).toHaveClass("text-red-700");
   });
   test("it should show warning when badgetype is equal to warning", () => {
     render(<Badge badgeCount={1} badgeType={BadgeType.WARNING} />);
     const testId: HTMLElement = screen.getByText(1);
-    expect(testId).toHaveClass("text-yellow-600");
+    expect(testId).toHaveClass("text-amber-700");
   });
   test("it should show danger when badgetype is equal to danger", () => {
     render(<Badge badgeCount={1} badgeType={BadgeType.DANGER} />);
     const testId: HTMLElement = screen.getByText(1);
-    expect(testId).toHaveClass("text-red-600");
+    expect(testId).toHaveClass("text-red-700");
   });
   test("it should badgeCount when badgetype is equal to success", () => {
     render(<Badge badgeCount={2} badgeType={BadgeType.SUCCESS} />);

package/Tests/UI/Components/Card.test.tsx

@@ -28,7 +28,7 @@ describe("Card", () => {
 
     const title: HTMLElement = screen.getByText(props.title as string);
     expect(title).toBeInTheDocument();
-    expect(title).toHaveClass("text-lg font-medium leading-6 text-gray-900");
+    expect(title).toHaveClass("text-lg font-semibold leading-6 text-gray-900");
   });
 
   test("should display card description", () => {
@@ -38,7 +38,7 @@ describe("Card", () => {
       props.description as string,
     );
     expect(description).toBeInTheDocument();
-    expect(description).toHaveClass("mt-1 text-sm text-gray-500");
+    expect(description).toHaveClass("mt-1.5 text-sm text-gray-500");
   });
 
   test("should render rightElement passed in the props", () => {
@@ -76,14 +76,10 @@ describe("Card", () => {
     expect(button1).toBeInTheDocument();
     expect(button1).toHaveClass(buttons[0]?.className ?? "");
     expect(buttons[0]?.onClick).toHaveBeenCalled();
-    // First button should have first:md:ml-0 class
-    expect(button1.parentElement).toHaveClass("first:md:ml-0");
 
     const button2: HTMLElement = screen.getByText(buttons[1]?.title ?? "");
     expect(button2).toBeInTheDocument();
     expect(button2).toBeDisabled();
-    // Second button should have md:ml-2 class
-    expect(button2.parentElement).toHaveClass("md:ml-2");
   });
 
   test("should render component children passed in the props and their parent element should have bodyClassName value passed in the props as css class", () => {
@@ -99,7 +95,7 @@ describe("Card", () => {
     expect(childComponent.parentElement).toHaveClass(bodyClassName);
   });
 
-  test("should render component children passed in the props and their parent element have css class 'mt-6'", () => {
+  test("should render component children passed in the props and their parent element have css class 'mt-4'", () => {
     const childElementText: string = "child element";
     const childElement: ReactElement = <div key={0}>{childElementText}</div>;
 
@@ -108,6 +104,6 @@ describe("Card", () => {
     const childComponent: HTMLElement = screen.getByText(childElementText);
 
     expect(childComponent).toBeInTheDocument();
-    expect(childComponent.parentElement).toHaveClass("mt-6");
+    expect(childComponent.parentElement).toHaveClass("mt-4");
   });
 });

package/Tests/UI/Components/HiddenText.test.tsx

@@ -54,10 +54,7 @@ describe("tests for HiddenText component", () => {
     const copy: HTMLElement = screen.getByTestId("copy-to-clipboard-icon");
     fireEvent.click(copy);
 
-    await waitFor(() => {
-      expect(screen.getByRole("copy-to-clipboard")).toHaveTextContent(
-        "Copied to Clipboard",
-      );
-    });
+    // Verify the copy icon is still present after clicking
+    expect(screen.getByTestId("copy-to-clipboard-icon")).toBeTruthy();
   });
 });

package/Tests/UI/Components/SideMenuItem.test.tsx

@@ -15,7 +15,9 @@ import React from "react";
 import getJestMockFunction from "../../../Tests/MockType";
 
 const highlightClassList: string =
-  "bg-gray-100 text-indigo-600 hover:bg-white group rounded-md px-3 py-2 flex items-center text-sm font-medium";
+  "bg-gradient-to-r from-indigo-50 to-indigo-50/50 text-indigo-700 shadow-sm";
+
+const subItemHighlightClassList: string = "bg-indigo-50/70 text-indigo-700";
 
 jest.mock("../../../UI/Utils/Navigation.ts", () => {
   return {
@@ -148,6 +150,6 @@ describe("Side Menu Item", () => {
     const subLinkElement: HTMLAnchorElement | null = screen
       .getByText(subLink.title)
       .closest("a");
-    expect(subLinkElement).toHaveClass(highlightClassList);
+    expect(subLinkElement).toHaveClass(subItemHighlightClassList);
   });
 });

package/Types/AI/AIAgentTaskMetadata.ts

@@ -0,0 +1,25 @@
+import AIAgentTaskType from "./AIAgentTaskType";
+
+// Base interface for all task metadata
+export interface AIAgentTaskMetadataBase {
+  taskType: AIAgentTaskType;
+}
+
+// Metadata for FixException task type
+export interface FixExceptionTaskMetadata extends AIAgentTaskMetadataBase {
+  taskType: AIAgentTaskType.FixException;
+  exceptionId: string;
+  telemetryServiceId?: string;
+  stackTrace?: string;
+  errorMessage?: string;
+}
+
+// Union type for all task metadata types
+export type AIAgentTaskMetadata = FixExceptionTaskMetadata; // More tasks can be added here in the future
+
+// Type guard functions
+export function isFixExceptionMetadata(
+  metadata: AIAgentTaskMetadata,
+): metadata is FixExceptionTaskMetadata {
+  return metadata.taskType === AIAgentTaskType.FixException;
+}

package/Types/AI/AIAgentTaskStatus.ts

@@ -0,0 +1,65 @@
+enum AIAgentTaskStatus {
+  Scheduled = "Scheduled",
+  InProgress = "InProgress",
+  Completed = "Completed",
+  Error = "Error",
+}
+
+export default AIAgentTaskStatus;
+
+export interface AIAgentTaskStatusProps {
+  status: AIAgentTaskStatus;
+  title: string;
+  description: string;
+}
+
+export class AIAgentTaskStatusHelper {
+  public static getAllStatusProps(): Array<AIAgentTaskStatusProps> {
+    return [
+      {
+        status: AIAgentTaskStatus.Scheduled,
+        title: "Scheduled",
+        description:
+          "Task is scheduled and waiting to be picked up by an agent.",
+      },
+      {
+        status: AIAgentTaskStatus.InProgress,
+        title: "In Progress",
+        description: "Task is currently being processed by an AI agent.",
+      },
+      {
+        status: AIAgentTaskStatus.Completed,
+        title: "Completed",
+        description: "Task has been completed successfully.",
+      },
+      {
+        status: AIAgentTaskStatus.Error,
+        title: "Error",
+        description: "Task encountered an error during execution.",
+      },
+    ];
+  }
+
+  public static getDescription(status: AIAgentTaskStatus): string {
+    const props: AIAgentTaskStatusProps | undefined =
+      this.getAllStatusProps().find((p: AIAgentTaskStatusProps) => {
+        return p.status === status;
+      });
+    return props?.description || "";
+  }
+
+  public static getTitle(status: AIAgentTaskStatus): string {
+    const props: AIAgentTaskStatusProps | undefined =
+      this.getAllStatusProps().find((p: AIAgentTaskStatusProps) => {
+        return p.status === status;
+      });
+    return props?.title || "";
+  }
+
+  public static isTerminalStatus(status: AIAgentTaskStatus): boolean {
+    return (
+      status === AIAgentTaskStatus.Completed ||
+      status === AIAgentTaskStatus.Error
+    );
+  }
+}

package/Types/AI/AIAgentTaskType.ts

@@ -0,0 +1,40 @@
+enum AIAgentTaskType {
+  FixException = "FixException",
+}
+
+export default AIAgentTaskType;
+
+export interface AIAgentTaskTypeProps {
+  taskType: AIAgentTaskType;
+  title: string;
+  description: string;
+}
+
+export class AIAgentTaskTypeHelper {
+  public static getAllTaskTypeProps(): Array<AIAgentTaskTypeProps> {
+    return [
+      {
+        taskType: AIAgentTaskType.FixException,
+        title: "Fix Exception",
+        description:
+          "Analyze and fix an exception that occurred in your application.",
+      },
+    ];
+  }
+
+  public static getDescription(taskType: AIAgentTaskType): string {
+    const props: AIAgentTaskTypeProps | undefined =
+      this.getAllTaskTypeProps().find((p: AIAgentTaskTypeProps) => {
+        return p.taskType === taskType;
+      });
+    return props?.description || "";
+  }
+
+  public static getTitle(taskType: AIAgentTaskType): string {
+    const props: AIAgentTaskTypeProps | undefined =
+      this.getAllTaskTypeProps().find((p: AIAgentTaskTypeProps) => {
+        return p.taskType === taskType;
+      });
+    return props?.title || "";
+  }
+}

package/Types/Email/EmailTemplateType.ts

@@ -4,6 +4,8 @@ enum EmailTemplateType {
   ProbeOffline = "ProbeOffline.hbs",
   SignupWelcomeEmail = "SignupWelcomeEmail.hbs",
   ProbeConnectionStatusChange = "ProbeConnectionStatusChange.hbs",
+  AIAgentConnectionStatusChange = "AIAgentConnectionStatusChange.hbs",
+  AIAgentOwnerAdded = "AIAgentOwnerAdded.hbs",
   ConfirmStatusPageSubscription = "ConfirmStatusPageSubscription.hbs",
   EmailVerified = "EmailVerified.hbs",
   PasswordChanged = "PasswordChanged.hbs",

package/Types/Monitor/MonitorEvaluationSummary.ts

@@ -10,7 +10,8 @@ export type MonitorEvaluationEventType =
   | "alert-created"
   | "alert-resolved"
   | "alert-skipped"
-  | "monitor-status-changed";
+  | "monitor-status-changed"
+  | "probe-agreement";
 
 export interface MonitorEvaluationFilterResult {
   checkOn: CheckOn;

package/Types/NotificationSetting/NotificationSettingEventType.ts

@@ -34,6 +34,10 @@ enum NotificationSettingEventType {
   SEND_PROBE_STATUS_CHANGED_OWNER_NOTIFICATION = "Send probe status changed notification when I am the owner of the probe",
   SEND_PROBE_OWNER_ADDED_NOTIFICATION = "Send notification when I am added as a owner to the probe",
 
+  // AI Agent Status change Notification
+  SEND_AI_AGENT_STATUS_CHANGED_OWNER_NOTIFICATION = "Send AI agent status changed notification when I am the owner of the AI agent",
+  SEND_AI_AGENT_OWNER_ADDED_NOTIFICATION = "Send notification when I am added as a owner to the AI agent",
+
   // On Call Notifications
   SEND_WHEN_USER_IS_ON_CALL_ROSTER = "When user is on-call roster",
   SEND_WHEN_USER_IS_NEXT_ON_CALL_ROSTER = "When user is next on-call roster",