@oneuptime/common 12.0.7 → 12.0.9

package/Server/Services/NetworkDeviceLinkService.ts

@@ -0,0 +1,84 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/NetworkDeviceLink";
+import NetworkDeviceService from "./NetworkDeviceService";
+import NetworkDevice from "../../Models/DatabaseModels/NetworkDevice";
+import { OnCreate } from "../Types/Database/Hooks";
+import CreateBy from "../Types/Database/CreateBy";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import QueryHelper from "../Types/Database/QueryHelper";
+import RelationIdUtil from "../Utils/Database/RelationIdUtil";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+
+// Both spellings of each end, for the same reason RelationIdUtil exists.
+const FROM_DEVICE_KEYS: Array<string> = ["fromDeviceId", "fromDevice"];
+const TO_DEVICE_KEYS: Array<string> = ["toDeviceId", "toDevice"];
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  /*
+   * Two guards, both about links that would be nonsense on the map:
+   *
+   *   - a device may not link to itself. The topology builder drops
+   *     self-edges anyway (the same rule LLDP self-reports hit), so such a
+   *     row would be invisible and permanently confusing.
+   *   - both ends must belong to the creating project. The FKs only require
+   *     the rows to exist, so without this a tenant could draw a line to
+   *     another project's device and read its name off the map.
+   */
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    const data: Record<string, unknown> = createBy.data as unknown as Record<
+      string,
+      unknown
+    >;
+
+    const fromDeviceId: ObjectID | null = RelationIdUtil.read(
+      data,
+      FROM_DEVICE_KEYS,
+    );
+    const toDeviceId: ObjectID | null = RelationIdUtil.read(
+      data,
+      TO_DEVICE_KEYS,
+    );
+
+    if (!fromDeviceId || !toDeviceId) {
+      throw new BadDataException("A link needs a device at each end.");
+    }
+
+    if (fromDeviceId.toString() === toDeviceId.toString()) {
+      throw new BadDataException("A device cannot be linked to itself.");
+    }
+
+    if (!createBy.data.projectId) {
+      throw new BadDataException("Project ID is required.");
+    }
+
+    const devices: Array<NetworkDevice> = await NetworkDeviceService.findBy({
+      query: {
+        _id: QueryHelper.any([fromDeviceId.toString(), toDeviceId.toString()]),
+        projectId: createBy.data.projectId,
+      },
+      select: { _id: true },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: { isRoot: true },
+    });
+
+    if (devices.length !== 2) {
+      throw new BadDataException(
+        "Both devices must exist and belong to this project.",
+      );
+    }
+
+    return { createBy, carryForward: null };
+  }
+}
+
+export default new Service();

package/Server/Services/NetworkDeviceService.ts

@@ -1,9 +1,11 @@
 import DatabaseService from "./DatabaseService";
+import MonitorService from "./MonitorService";
 import NetworkDeviceLabelRuleEngineService from "./NetworkDeviceLabelRuleEngineService";
 import NetworkDeviceOwnerRuleEngineService from "./NetworkDeviceOwnerRuleEngineService";
 import NetworkSiteAssignmentRuleService from "./NetworkSiteAssignmentRuleService";
 import NetworkSiteService from "./NetworkSiteService";
 import Model from "../../Models/DatabaseModels/NetworkDevice";
+import Monitor from "../../Models/DatabaseModels/Monitor";
 import NetworkSite from "../../Models/DatabaseModels/NetworkSite";
 import NetworkSiteAssignmentRule from "../../Models/DatabaseModels/NetworkSiteAssignmentRule";
 import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
@@ -18,6 +20,7 @@ import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
 import OneUptimeDate from "../../Types/Date";
 import CidrMatchUtil from "../../Utils/NetworkSite/CidrMatchUtil";
+import { NetworkDeviceMonitoringMethodUtil } from "../../Types/NetworkDevice/NetworkDeviceMonitoringMethod";
 import RelationIdUtil from "../Utils/Database/RelationIdUtil";
 import { EntityManager } from "typeorm";
 
@@ -68,6 +71,13 @@ function readSiteIdFromData(data: Record<string, unknown>): ObjectID | null {
   return RelationIdUtil.read(data, SITE_KEYS);
 }
 
+// Both spellings of "the monitor that reports this device's health".
+const MONITOR_KEYS: Array<string> = ["monitorId", "monitor"];
+
+function readMonitorIdFromData(data: Record<string, unknown>): ObjectID | null {
+  return RelationIdUtil.read(data, MONITOR_KEYS);
+}
+
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
@@ -152,9 +162,71 @@ export class Service extends DatabaseService<Model> {
       });
     }
 
+    if (
+      NetworkDeviceMonitoringMethodUtil.isMonitorBacked(
+        createBy.data.monitoringMethod,
+      )
+    ) {
+      const monitorId: ObjectID | null = readMonitorIdFromData(
+        createBy.data as unknown as Record<string, unknown>,
+      );
+
+      /*
+       * The monitor is NOT required here, though the create form asks for
+       * one. Discovery import is why: a subnet sweep finds ping-only hosts
+       * in bulk and there is no monitor to bind them to yet. Such a device
+       * is still worth recording — it belongs to a site, carries labels, and
+       * appears on the topology map — and its status reads "pending", which
+       * is exactly true until somebody points a monitor at it.
+       */
+      if (monitorId) {
+        await this.assertMonitorBelongsToProject({
+          monitorId: monitorId,
+          projectId: createBy.data.projectId,
+        });
+      }
+
+      /*
+       * Not a preference: a monitor-backed device has no probe and no
+       * credentials, so leaving polling on would queue a walk that can only
+       * ever fail. claimDevicesForPolling refuses these rows too — this is
+       * the half that keeps the column honest for anything reading it.
+       */
+      createBy.data.isPollingEnabled = false;
+    }
+
     return { createBy, carryForward: null };
   }
 
+  /*
+   * The FK behind monitorId only requires the Monitor row to exist, not that
+   * it belongs to the device's project — the same hole assertSiteBelongsToProject
+   * closes for sites. Without this a tenant could bind a device to another
+   * project's monitor and read its status through the device.
+   */
+  @CaptureSpan()
+  private async assertMonitorBelongsToProject(data: {
+    monitorId: ObjectID;
+    projectId: ObjectID | undefined;
+  }): Promise<void> {
+    if (!data.projectId) {
+      throw new BadDataException("Project ID is required.");
+    }
+
+    const monitor: Monitor | null = await MonitorService.findOneBy({
+      query: {
+        _id: data.monitorId,
+        projectId: data.projectId,
+      },
+      select: { _id: true },
+      props: { isRoot: true },
+    });
+
+    if (!monitor) {
+      throw new BadDataException("Monitor not found.");
+    }
+  }
+
   /*
    * Owner/label rules fire whenever a device is created — manually or via
    * subnet discovery import. Applied out-of-band: rule failures must never
@@ -222,6 +294,71 @@ export class Service extends DatabaseService<Model> {
   ): Promise<OnUpdate<Model>> {
     const dataKeys: Array<string> = Object.keys(updateBy.data || {});
 
+    /*
+     * Switching a device to monitor-backed turns polling off with it. The
+     * two are one decision, not two: a device with no probe and no
+     * credentials cannot be walked, so leaving the flag on would queue a
+     * walk per interval that can only fail and then paint the device down.
+     */
+    const isMethodWrite: boolean = dataKeys.includes("monitoringMethod");
+    /*
+     * An update payload is a QueryDeepPartialEntity, so a column can hold a
+     * raw value OR a SQL-expression function. Only a plain string is a
+     * method we can reason about; anything else falls through to the SNMP
+     * default, which changes nothing.
+     */
+    const writtenMethod: unknown = (
+      updateBy.data as unknown as Record<string, unknown>
+    )["monitoringMethod"];
+    const becomesMonitorBacked: boolean =
+      isMethodWrite &&
+      typeof writtenMethod === "string" &&
+      NetworkDeviceMonitoringMethodUtil.isMonitorBacked(writtenMethod);
+
+    if (becomesMonitorBacked) {
+      updateBy.data.isPollingEnabled = false;
+    }
+
+    /*
+     * Turning polling back ON is the other direction, and it has to be
+     * refused rather than quietly ignored: claimDevicesForPolling skips
+     * monitor-backed rows whatever this column says, so a device left with
+     * the flag on would read "polling enabled" in the UI forever while
+     * nothing ever polled it. Only checked when the payload actually asks
+     * for it, so the ordinary update path costs no extra query.
+     */
+    if (
+      !becomesMonitorBacked &&
+      dataKeys.includes("isPollingEnabled") &&
+      updateBy.data.isPollingEnabled === true
+    ) {
+      const targets: Array<Model> = await this.findBy({
+        query: this.scopeQueryToCallerTenant(updateBy.query, updateBy.props),
+        select: {
+          _id: true,
+          monitoringMethod: true,
+        },
+        limit: LIMIT_MAX,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+
+      const isTargetMonitorBacked: boolean = targets.some((target: Model) => {
+        return NetworkDeviceMonitoringMethodUtil.isMonitorBacked(
+          target.monitoringMethod,
+        );
+      });
+
+      // Unless the same write is moving it back to SNMP, which is allowed.
+      if (isTargetMonitorBacked && !(isMethodWrite && !becomesMonitorBacked)) {
+        throw new BadDataException(
+          "This device is monitor-backed, so there is nothing to poll — it has no probe and no SNMP credentials. Switch its monitoring method to SNMP first.",
+        );
+      }
+    }
+
     const isSiteChange: boolean = isSiteWrite(dataKeys);
     const isIdentityChange: boolean = SITE_RULE_IDENTITY_COLUMNS.some(
       (column: string) => {
@@ -545,6 +682,9 @@ export class Service extends DatabaseService<Model> {
           AND nd."isPollingEnabled" = true
           AND nd."deletedAt" IS NULL
           AND nd."hostname" IS NOT NULL
+          -- A monitor-backed device has no credentials to walk with. NULL is
+          -- every device created before the column existed: those are SNMP.
+          AND (nd."monitoringMethod" IS NULL OR nd."monitoringMethod" <> 'Monitor')
           AND (nd."nextPollAt" IS NULL OR nd."nextPollAt" <= $2)
           AND p."deletedAt" IS NULL
           AND (p."paymentProviderSubscriptionStatus" IS NULL

package/Server/Services/NetworkSiteService.ts

@@ -1173,10 +1173,20 @@ export class Service extends DatabaseService<Model> {
 
   /*
    * Called by MonitorService.changeMonitorStatus after a status persists.
-   * Resolves which NetworkDevices the monitors reference in their steps,
-   * stamps those devices' currentMonitorStatusId, then recomputes the
-   * rollup for every affected site chain. Never throws - a rollup failure
-   * must never break a monitor status change.
+   * Resolves which NetworkDevices these monitors report on, stamps those
+   * devices' currentMonitorStatusId, then recomputes the rollup for every
+   * affected site chain. Never throws - a rollup failure must never break a
+   * monitor status change.
+   *
+   * A device is reached two ways, and both are checked:
+   *
+   *   - a Network Device monitor names it inside its step data. This is the
+   *     SNMP path: the device is polled by its probe and the monitor exists
+   *     to alert on what the walk reports.
+   *   - the device points AT a monitor through monitorId. This is the
+   *     monitor-backed path (monitoringMethod "Monitor") for gear that does
+   *     not speak SNMP, so ANY monitor type qualifies — a Ping monitor on an
+   *     access point is the whole point of it.
    */
   @CaptureSpan()
   public async onMonitorStatusChanged(data: {
@@ -1207,33 +1217,75 @@ export class Service extends DatabaseService<Model> {
         },
       });
 
-      if (monitors.length === 0) {
-        return;
+      const referencedDeviceIds: Array<string> =
+        monitors.length > 0
+          ? NetworkDeviceHydrationUtil.getReferencedNetworkDeviceIds(monitors)
+          : [];
+
+      /*
+       * Deduplicated by id, because a device can legitimately be reached
+       * both ways — an SNMP-polled device may also carry a monitorId — and
+       * stamping it twice would double every rollup it triggers.
+       */
+      const devicesById: Map<string, NetworkDevice> = new Map<
+        string,
+        NetworkDevice
+      >();
+
+      const collect: (rows: Array<NetworkDevice>) => void = (
+        rows: Array<NetworkDevice>,
+      ): void => {
+        for (const row of rows) {
+          if (row.id) {
+            devicesById.set(row.id.toString(), row);
+          }
+        }
+      };
+
+      if (referencedDeviceIds.length > 0) {
+        collect(
+          await NetworkDeviceService.findBy({
+            query: {
+              _id: QueryHelper.any(referencedDeviceIds),
+              projectId: data.projectId,
+            },
+            select: {
+              _id: true,
+              siteId: true,
+            },
+            limit: LIMIT_MAX,
+            skip: 0,
+            props: {
+              isRoot: true,
+            },
+          }),
+        );
       }
 
-      const deviceIds: Array<string> =
-        NetworkDeviceHydrationUtil.getReferencedNetworkDeviceIds(monitors);
+      collect(
+        await NetworkDeviceService.findBy({
+          query: {
+            monitorId: QueryHelper.any(data.monitorIds),
+            projectId: data.projectId,
+          },
+          select: {
+            _id: true,
+            siteId: true,
+          },
+          limit: LIMIT_MAX,
+          skip: 0,
+          props: {
+            isRoot: true,
+          },
+        }),
+      );
+
+      const devices: Array<NetworkDevice> = Array.from(devicesById.values());
 
-      if (deviceIds.length === 0) {
+      if (devices.length === 0) {
         return;
       }
 
-      const devices: Array<NetworkDevice> = await NetworkDeviceService.findBy({
-        query: {
-          _id: QueryHelper.any(deviceIds),
-          projectId: data.projectId,
-        },
-        select: {
-          _id: true,
-          siteId: true,
-        },
-        limit: LIMIT_MAX,
-        skip: 0,
-        props: {
-          isRoot: true,
-        },
-      });
-
       for (const device of devices) {
         if (!device.id) {
           continue;

package/Server/Services/NetworkTopologySuppressionService.ts

@@ -0,0 +1,84 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/NetworkTopologySuppression";
+import { OnCreate } from "../Types/Database/Hooks";
+import CreateBy from "../Types/Database/CreateBy";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import BadDataException from "../../Types/Exception/BadDataException";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  /*
+   * Hiding a node twice is a no-op the UI should not have to guard against —
+   * a second click, two people on the same map — so a duplicate is rejected
+   * rather than quietly creating a second row that would then need deleting
+   * twice to restore the node.
+   */
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    const nodeKey: string | undefined = createBy.data.nodeKey?.trim();
+
+    if (!nodeKey) {
+      throw new BadDataException("Node key is required.");
+    }
+
+    createBy.data.nodeKey = nodeKey;
+
+    if (!createBy.data.projectId) {
+      throw new BadDataException("Project ID is required.");
+    }
+
+    const existing: Model | null = await this.findOneBy({
+      query: {
+        projectId: createBy.data.projectId,
+        nodeKey: nodeKey,
+      },
+      select: { _id: true },
+      props: { isRoot: true },
+    });
+
+    if (existing) {
+      throw new BadDataException("This node is already hidden from the map.");
+    }
+
+    return { createBy, carryForward: null };
+  }
+
+  /*
+   * The node keys hidden in a project, for the topology builder. Returns a
+   * Set so the builder's per-node lookup stays O(1).
+   */
+  @CaptureSpan()
+  public async getSuppressedNodeKeys(data: {
+    projectId: Model["projectId"];
+  }): Promise<Set<string>> {
+    if (!data.projectId) {
+      return new Set<string>();
+    }
+
+    const rows: Array<Model> = await this.findBy({
+      query: { projectId: data.projectId },
+      select: { nodeKey: true },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: { isRoot: true },
+    });
+
+    return new Set<string>(
+      rows
+        .map((row: Model) => {
+          return row.nodeKey || "";
+        })
+        .filter((key: string) => {
+          return key.length > 0;
+        }),
+    );
+  }
+}
+
+export default new Service();

package/Server/Services/OnCallDutyPolicyEscalationRuleScheduleService.ts

@@ -85,6 +85,43 @@ export class Service extends DatabaseService<Model> {
         },
       );
 
+    /*
+     * Record the attachment in the policy feed BEFORE the early return below.
+     *
+     * This used to sit at the bottom of the method, after `if (!userOnSchedule)
+     * return`, so attaching a schedule that happened to have nobody on call at
+     * that instant produced no feed item and no workspace message at all — the
+     * audit trail silently depended on the roster state at the moment of the
+     * click. Note the asymmetry it created: the delete path emits its feed item
+     * from onBeforeDelete, which runs unconditionally, so removals were always
+     * recorded while additions could vanish.
+     *
+     * When nobody is on call, the entry says so — attaching a schedule that
+     * currently pages no one is exactly the thing an operator wants to see.
+     */
+    const feedOnCallDutyPolicyId: ObjectID | undefined | null =
+      createdModel.onCallDutyPolicy?.id;
+
+    if (feedOnCallDutyPolicyId) {
+      const noCoverageSuffix: string = userOnSchedule
+        ? ""
+        : " ⚠️ **No one is currently on call in this schedule**, so alerts escalating to this rule will not notify anyone until coverage resumes.";
+
+      await OnCallDutyPolicyFeedService.createOnCallDutyPolicyFeedItem({
+        onCallDutyPolicyId: feedOnCallDutyPolicyId,
+        projectId: createdModel.projectId!,
+        onCallDutyPolicyFeedEventType:
+          OnCallDutyPolicyFeedEventType.OnCallDutyScheduleAdded,
+        displayColor: userOnSchedule ? Gray500 : Red500,
+        feedInfoInMarkdown: `📅 Added on-call schedule **${createdModel.onCallDutyPolicySchedule?.name || ""}** from the [On-Call Policy ${createdModel.onCallDutyPolicy?.name || ""}](${(await OnCallDutyPolicyService.getOnCallDutyPolicyLinkInDashboard(createdModel.projectId!, feedOnCallDutyPolicyId)).toString()}) escalation rule **${createdModel.onCallDutyPolicyEscalationRule?.name}** with order **${createdModel.onCallDutyPolicyEscalationRule?.order}**.${noCoverageSuffix}`,
+        userId: createdModel.createdByUserId || undefined,
+        workspaceNotification: {
+          sendWorkspaceNotification: true,
+          notifyUserId: createdModel.createdByUserId || undefined,
+        },
+      });
+    }
+
     if (!userOnSchedule) {
       return createdItem;
     }
@@ -202,35 +239,10 @@ export class Service extends DatabaseService<Model> {
       eventType,
     });
 
-    // add workspace message.
-
-    const onCallDutyPolicyId: ObjectID | undefined | null =
-      createdModel.onCallDutyPolicy!.id;
-    const projectId: ObjectID | undefined = createdModel.projectId;
-
-    const createdByUserId: ObjectID | undefined | null =
-      createdModel.createdByUserId;
-
-    const onCallSchedule: OnCallDutyPolicySchedule | undefined =
-      createdModel.onCallDutyPolicySchedule;
-    const onCallDutyPolicyName: string | null =
-      createdModel.onCallDutyPolicy?.name || "";
-
-    if (onCallDutyPolicyId) {
-      await OnCallDutyPolicyFeedService.createOnCallDutyPolicyFeedItem({
-        onCallDutyPolicyId: onCallDutyPolicyId,
-        projectId: projectId!,
-        onCallDutyPolicyFeedEventType:
-          OnCallDutyPolicyFeedEventType.OnCallDutyScheduleAdded,
-        displayColor: Gray500,
-        feedInfoInMarkdown: `📅 Added on-call schedule **${onCallSchedule?.name || ""}** from the [On-Call Policy ${onCallDutyPolicyName}](${(await OnCallDutyPolicyService.getOnCallDutyPolicyLinkInDashboard(projectId!, onCallDutyPolicyId!)).toString()}) escalation rule **${createdModel.onCallDutyPolicyEscalationRule?.name}** with order **${createdModel.onCallDutyPolicyEscalationRule?.order}**.`,
-        userId: createdByUserId || undefined,
-        workspaceNotification: {
-          sendWorkspaceNotification: true,
-          notifyUserId: createdByUserId || undefined,
-        },
-      });
-    }
+    /*
+     * The "schedule added" feed item is emitted above, before the
+     * no-one-on-call early return, so it is recorded unconditionally.
+     */
 
     return createdItem;
   }

package/Server/Services/OnCallDutyPolicyExecutionLogService.ts

@@ -332,6 +332,12 @@ export class Service extends DatabaseService<Model> {
         return Yellow500;
       case OnCallDutyPolicyStatus.Completed:
         return Green500;
+      /*
+       * Amber, not green: the policy finished, but finishing without paging
+       * anyone is a failure of the thing the policy exists to do.
+       */
+      case OnCallDutyPolicyStatus.CompletedWithNoNotifications:
+        return Yellow500;
       case OnCallDutyPolicyStatus.Error:
         return Red500;
       default:
@@ -349,6 +355,8 @@ export class Service extends DatabaseService<Model> {
         return "▶️";
       case OnCallDutyPolicyStatus.Completed:
         return "🏁";
+      case OnCallDutyPolicyStatus.CompletedWithNoNotifications:
+        return "⚠️";
       case OnCallDutyPolicyStatus.Error:
         return "❌";
       default:

package/Server/Services/OnCallDutyPolicyExecutionLogTimelineService.ts

@@ -91,6 +91,13 @@ export class Service extends DatabaseService<Model> {
           triggeredByIncidentId: true,
           triggeredByAlertId: true,
           triggeredByAlertEpisodeId: true,
+          /*
+           * Was missing from this select while the guard below (and the feed
+           * branch further down) read it — so it was always undefined and every
+           * incident-episode-triggered execution returned early, producing no
+           * on-call feed entries at all for that trigger type.
+           */
+          triggeredByIncidentEpisodeId: true,
           projectId: true,
           status: true,
           statusMessage: true,
@@ -221,21 +228,63 @@ export class Service extends DatabaseService<Model> {
           incidentOrAlertLink = `[Incident Episode ${incidentEpisodeNumberResult.numberWithPrefix || "#" + incidentEpisodeNumberResult.number}](${(await IncidentEpisodeService.getEpisodeLinkInDashboard(onCallDutyPolicyExecutionLogTimeline.projectId!, onCallDutyPolicyExecutionLogTimeline.triggeredByIncidentEpisodeId)).toString()})`;
         }
 
-        let feedInfoInMarkdown: string = `**${this.getEmojiBasedOnStatus(status)} ${incidentOrAlertLink} On-Call Alert ${status} to ${await UserService.getUserMarkdownString(
-          {
-            userId: onCallDutyPolicyExecutionLogTimeline.alertSentToUserId!,
-            projectId: onCallDutyPolicyExecutionLogTimeline.projectId!,
-          },
-        )}**
+        const policyLink: string = `**[${onCallDutyPolicyExecutionLogTimeline.onCallDutyPolicy.name}](${(await OnCallDutyPolicyService.getOnCallDutyPolicyLinkInDashboard(onCallDutyPolicyExecutionLogTimeline.projectId!, onCallDutyPolicyExecutionLogTimeline.onCallDutyPolicy.id!)).toString()})**`;
 
-The on-call policy **[${onCallDutyPolicyExecutionLogTimeline.onCallDutyPolicy.name}](${(await OnCallDutyPolicyService.getOnCallDutyPolicyLinkInDashboard(onCallDutyPolicyExecutionLogTimeline.projectId!, onCallDutyPolicyExecutionLogTimeline.onCallDutyPolicy.id!)).toString()})** has been triggered. The escalation rule **${onCallDutyPolicyExecutionLogTimeline.onCallDutyPolicyEscalationRule?.name}** ${onCallDutyPolicyExecutionLogTimeline.onCallDutySchedule?.name ? String(" and schedule **" + onCallDutyPolicyExecutionLogTimeline.onCallDutySchedule?.name + "**") : ""} were applied. ${await UserService.getUserMarkdownString(
-          {
-            userId: onCallDutyPolicyExecutionLogTimeline.alertSentToUserId!,
-            projectId: onCallDutyPolicyExecutionLogTimeline.projectId!,
-          },
-        )} was alerted. The status of this alert is **${status}** with the message: \`${onCallDutyPolicyExecutionLogTimeline.statusMessage}\`. ${onCallDutyPolicyExecutionLogTimeline.userBelongsToTeam?.name ? "The alert was sent because the user belogs to the team **" + onCallDutyPolicyExecutionLogTimeline.userBelongsToTeam?.name + "** " : ""} ${onCallDutyPolicyExecutionLogTimeline.isAcknowledged ? "The alert was acknowledged at **" + onCallDutyPolicyExecutionLogTimeline.acknowledgedAt + "** " : ""}`;
+        const scheduleClause: string = onCallDutyPolicyExecutionLogTimeline
+          .onCallDutySchedule?.name
+          ? String(
+              " and schedule **" +
+                onCallDutyPolicyExecutionLogTimeline.onCallDutySchedule?.name +
+                "**",
+            )
+          : "";
+
+        /*
+         * Some timeline rows have NO recipient by construction: a schedule that
+         * currently has nobody on call (a coverage gap), or an escalation rule
+         * with no responders at all. Those rows are exactly the ones an operator
+         * most needs to understand, so they get their own wording.
+         *
+         * Building the "was alerted" sentence for them used to interpolate
+         * `alertSentToUserId!` — a non-null assertion on a field that is never
+         * set here — which rendered a feed entry claiming somebody was paged
+         * when in fact nobody was.
+         */
+        const hasRecipient: boolean = Boolean(
+          onCallDutyPolicyExecutionLogTimeline.alertSentToUserId,
+        );
+
+        let feedInfoInMarkdown: string = "";
+
+        if (!hasRecipient) {
+          const noRecipientReason: string = onCallDutyPolicyExecutionLogTimeline
+            .onCallDutySchedule?.name
+            ? `no one was on call in schedule **${onCallDutyPolicyExecutionLogTimeline.onCallDutySchedule.name}**`
+            : "this escalation rule had no responders";
+
+          feedInfoInMarkdown = `**${this.getEmojiBasedOnStatus(status)} ${incidentOrAlertLink} On-Call Alert ${status} — nobody was notified**
+
+The on-call policy ${policyLink} has been triggered. The escalation rule **${onCallDutyPolicyExecutionLogTimeline.onCallDutyPolicyEscalationRule?.name}**${scheduleClause} were applied, but ${noRecipientReason}, so **no one was notified at this step**. The status of this step is **${status}** with the message: \`${onCallDutyPolicyExecutionLogTimeline.statusMessage}\`.`;
+        } else {
+          feedInfoInMarkdown = `**${this.getEmojiBasedOnStatus(status)} ${incidentOrAlertLink} On-Call Alert ${status} to ${await UserService.getUserMarkdownString(
+            {
+              userId: onCallDutyPolicyExecutionLogTimeline.alertSentToUserId!,
+              projectId: onCallDutyPolicyExecutionLogTimeline.projectId!,
+            },
+          )}**
+
+The on-call policy ${policyLink} has been triggered. The escalation rule **${onCallDutyPolicyExecutionLogTimeline.onCallDutyPolicyEscalationRule?.name}** ${scheduleClause} were applied. ${await UserService.getUserMarkdownString(
+            {
+              userId: onCallDutyPolicyExecutionLogTimeline.alertSentToUserId!,
+              projectId: onCallDutyPolicyExecutionLogTimeline.projectId!,
+            },
+          )} was alerted. The status of this alert is **${status}** with the message: \`${onCallDutyPolicyExecutionLogTimeline.statusMessage}\`. ${onCallDutyPolicyExecutionLogTimeline.userBelongsToTeam?.name ? "The alert was sent because the user belogs to the team **" + onCallDutyPolicyExecutionLogTimeline.userBelongsToTeam?.name + "** " : ""} ${onCallDutyPolicyExecutionLogTimeline.isAcknowledged ? "The alert was acknowledged at **" + onCallDutyPolicyExecutionLogTimeline.acknowledgedAt + "** " : ""}`;
+        }
 
-        if (onCallDutyPolicyExecutionLogTimeline.overridedByUser) {
+        if (
+          hasRecipient &&
+          onCallDutyPolicyExecutionLogTimeline.overridedByUser
+        ) {
           feedInfoInMarkdown += `The alert was supposed to be sent to **${await UserService.getUserMarkdownString(
             {
               userId: onCallDutyPolicyExecutionLogTimeline.overridedByUser.id!,