@oneuptime/common 14.0.2 → 14.0.3

package/Server/Services/IncidentService.ts

@@ -111,6 +111,10 @@ import IncidentAIContextBuilder, {
   AIGenerationContext,
   IncidentContextData,
 } from "../Utils/AI/IncidentAIContextBuilder";
+import IncidentAlertService, {
+  LinkAlertsToIncidentResult,
+} from "./IncidentAlertService";
+import { INCIDENT_ALERT_IDS_TO_LINK_KEY } from "../../Types/Incident/IncidentAlertLink";
 
 // key is incidentId for this dictionary.
 type UpdateCarryForward = Dictionary<{
@@ -120,6 +124,15 @@ type UpdateCarryForward = Dictionary<{
   newMonitorChangeStatusIdTo: ObjectID | undefined;
 }>;
 
+/*
+ * What onBeforeCreate hands to onCreateSuccess. Null unless the incident is
+ * being declared from alerts.
+ */
+type IncidentCreateCarryForward = {
+  // Validated, deduplicated alert ids to link once the incident exists.
+  alertIdsToLink: Array<ObjectID>;
+} | null;
+
 type IncidentUpdatePayload = {
   postmortemNote?: string | null;
   title?: string | null;
@@ -783,6 +796,30 @@ export class Service extends DatabaseService<Model> {
     const projectId: ObjectID =
       createBy.props.tenantId || createBy.data.projectId!;
 
+    /*
+     * Declaring the incident from alerts. The alert ids are checked here,
+     * before the incident number is taken and before anything is written, so
+     * a bad id (a typo, another project's alert, an alert the caller cannot
+     * see, too many alerts) rejects the whole request instead of leaving an
+     * incident behind that is missing some of its alerts. The alerts are
+     * linked in onCreateSuccess, once the incident exists.
+     */
+    let carryForward: IncidentCreateCarryForward = null;
+
+    const alertIdsToLink: unknown =
+      createBy.miscDataProps?.[INCIDENT_ALERT_IDS_TO_LINK_KEY];
+
+    if (alertIdsToLink !== undefined && alertIdsToLink !== null) {
+      carryForward = {
+        alertIdsToLink:
+          await IncidentAlertService.validateAlertIdsForNewIncident({
+            projectId: projectId,
+            alertIds: alertIdsToLink,
+            props: createBy.props,
+          }),
+      };
+    }
+
     if (!createBy.data.declaredAt) {
       createBy.data.declaredAt = OneUptimeDate.getCurrentDate();
     } else {
@@ -1179,7 +1216,7 @@ export class Service extends DatabaseService<Model> {
 
     return {
       createBy,
-      carryForward: null,
+      carryForward: carryForward,
     };
   }
 
@@ -1267,14 +1304,16 @@ export class Service extends DatabaseService<Model> {
      */
     let aiInvestigationEnqueued: boolean = false;
 
-    // Execute operations sequentially with error handling
-    Promise.resolve()
-      .then(async () => {
-        /*
-         * Apply privacy rules BEFORE workspace operations so the workspace
-         * channel is created with the correct privacy setting. This may set
-         * createdItem.isPrivate=true in memory.
-         */
+    /*
+     * Apply privacy rules BEFORE workspace operations so the workspace
+     * channel is created with the correct privacy setting. This may set
+     * createdItem.isPrivate=true in memory. Kept as its own promise (it never
+     * rejects) so declaring from alerts can wait for it before linking: the
+     * links' feed entries leave out a private incident's title, so they must
+     * see the privacy the rules settle on.
+     */
+    const privacyRulesApplied: Promise<void> = Promise.resolve().then(
+      async () => {
         try {
           await IncidentPrivacyRuleEngineService.applyRulesToIncident(
             createdItem,
@@ -1288,7 +1327,11 @@ export class Service extends DatabaseService<Model> {
             } as LogAttributes,
           );
         }
-      })
+      },
+    );
+
+    // Execute operations sequentially with error handling
+    privacyRulesApplied
       .then(async () => {
         try {
           if (createdItem.projectId && createdItem.id) {
@@ -1324,6 +1367,67 @@ export class Service extends DatabaseService<Model> {
           return Promise.resolve();
         }
       })
+      .then(async () => {
+        /*
+         * Declared from alerts: announce the alerts once, here - after
+         * "Incident Created" and after the incident's Slack / Microsoft
+         * Teams channels exist - rather than once per alert as each link is
+         * written (see linkAlertsDeclaredWithIncident). Uses the validated
+         * ids, so it does not wait for the links.
+         */
+        try {
+          const alertIds: Array<ObjectID> =
+            this.getAlertIdsDeclaredWith(onCreate);
+
+          if (alertIds.length > 0) {
+            await IncidentAlertService.createDeclaredFromAlertsFeedItem({
+              projectId: createdItem.projectId!,
+              incidentId: createdItem.id!,
+              alertIds: alertIds,
+              actorUserId: this.getDeclaringUserId(onCreate, createdItem),
+            });
+          }
+        } catch (error) {
+          logger.error(
+            `Announcing the alerts an incident was declared from failed in IncidentService.onCreateSuccess: ${error}`,
+            {
+              projectId: createdItem.projectId?.toString(),
+              incidentId: createdItem.id?.toString(),
+            } as LogAttributes,
+          );
+        }
+      })
+      .then(async () => {
+        /*
+         * A private incident declared from alerts - private from the form or
+         * made private by a privacy rule above - gets the alerts' owners as
+         * its owners, so the people who could see the alerts can see the
+         * incident. Here rather than before the request returns: the owners'
+         * own hooks invite them to the incident's Slack / Microsoft Teams
+         * channels, which exist only from the workspace step above, and their
+         * "owner added" entries belong after "Incident Created".
+         */
+        try {
+          const alertIds: Array<ObjectID> =
+            this.getAlertIdsDeclaredWith(onCreate);
+
+          if (alertIds.length > 0 && createdItem.isPrivate === true) {
+            await IncidentAlertService.copyAlertOwnersToIncident({
+              projectId: createdItem.projectId!,
+              incidentId: createdItem.id!,
+              alertIds: alertIds,
+            });
+          }
+        } catch (error) {
+          logger.error(
+            `Adding the owners of the alerts a private incident was declared from failed in IncidentService.onCreateSuccess: ${error}`,
+            {
+              projectId: createdItem.projectId?.toString(),
+              incidentId: createdItem.id?.toString(),
+            } as LogAttributes,
+          );
+        }
+      })
       .then(async () => {
         try {
           return await this.handleIncidentStateChangeAsync(createdItem);
@@ -1623,9 +1727,105 @@ export class Service extends DatabaseService<Model> {
         );
       });
 
+    await this.linkAlertsDeclaredWithIncident(
+      onCreate,
+      createdItem,
+      privacyRulesApplied,
+    );
+
     return createdItem;
   }
 
+  // The validated alert ids an incident is being declared from, if any.
+  private getAlertIdsDeclaredWith(onCreate: OnCreate<Model>): Array<ObjectID> {
+    const carryForward: IncidentCreateCarryForward =
+      (onCreate.carryForward as IncidentCreateCarryForward) || null;
+
+    return carryForward?.alertIdsToLink || [];
+  }
+
+  /*
+   * Who declared the incident, as "Linked by" on the links and the actor of
+   * their feed entries. A user is recorded as themselves and an API key as
+   * nobody: Incident.createdByUserId is writable by the create payload, and
+   * an API key must not be able to name somebody else as the one who linked
+   * the alerts (IncidentAlertService.onBeforeCreate applies the same rule to
+   * a link created directly). Only an internal root caller is trusted to
+   * name the incident's creator.
+   */
+  private getDeclaringUserId(
+    onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): ObjectID | undefined {
+    if (onCreate.createBy.props.isRoot) {
+      return createdItem.createdByUserId || undefined;
+    }
+
+    return onCreate.createBy.props.userId || undefined;
+  }
+
+  /*
+   * The incident was declared from alerts (see onBeforeCreate): link them now
+   * that it exists. Awaited, unlike the chain above, so the incident page the
+   * user lands on already lists its alerts. Written as root because the
+   * caller's right to link them was checked before the incident was created;
+   * the user who declared the incident is recorded as the one who linked
+   * them. The links write no incident-side feed entries: the chain above
+   * posts one "Declared from N alerts" entry instead. A link that fails is
+   * logged and never fails the incident.
+   *
+   * The privacy rules run first: each link's entry on its alert leaves out
+   * the incident's title when the incident is private, and a rule can make
+   * it private after it was saved. (The alerts' owners are added to a private
+   * incident later in the chain, once its workspace channels exist.)
+   */
+  @CaptureSpan()
+  private async linkAlertsDeclaredWithIncident(
+    onCreate: OnCreate<Model>,
+    createdItem: Model,
+    privacyRulesApplied: Promise<void>,
+  ): Promise<void> {
+    const alertIds: Array<ObjectID> = this.getAlertIdsDeclaredWith(onCreate);
+
+    if (alertIds.length === 0 || !createdItem.projectId || !createdItem.id) {
+      return;
+    }
+
+    await privacyRulesApplied;
+
+    try {
+      const result: LinkAlertsToIncidentResult =
+        await IncidentAlertService.linkAlertsToIncident({
+          projectId: createdItem.projectId,
+          incidentId: createdItem.id,
+          alertIds: alertIds,
+          createdByUserId: this.getDeclaringUserId(onCreate, createdItem),
+          declaredWithIncident: true,
+          props: {
+            isRoot: true,
+          },
+        });
+
+      if (result.failed.length > 0) {
+        logger.error(
+          `${result.failed.length} of ${alertIds.length} alerts could not be linked to the incident they were declared with.`,
+          {
+            projectId: createdItem.projectId.toString(),
+            incidentId: createdItem.id.toString(),
+          } as LogAttributes,
+        );
+      }
+    } catch (error) {
+      logger.error(
+        `Linking the alerts an incident was declared from failed in IncidentService.onCreateSuccess: ${error}`,
+        {
+          projectId: createdItem.projectId.toString(),
+          incidentId: createdItem.id.toString(),
+        } as LogAttributes,
+      );
+    }
+  }
+
   @CaptureSpan()
   private async handleIncidentWorkspaceOperationsAsync(
     createdItem: Model,

package/Server/Services/IncidentStateTimelineService.ts

@@ -37,6 +37,7 @@ import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import WorkspaceNotificationRuleService from "./WorkspaceNotificationRuleService";
 import Semaphore, { SemaphoreMutex } from "../Infrastructure/Semaphore";
+import IncidentAlertService from "./IncidentAlertService";
 
 export class Service extends DatabaseService<IncidentStateTimeline> {
   public constructor() {
@@ -485,6 +486,29 @@ export class Service extends DatabaseService<IncidentStateTimeline> {
       }
     }
 
+    /*
+     * Carry the incident's new state over to its linked alerts, when the
+     * project has opted in (acknowledge and/or resolve them with the
+     * incident). Only for the incident's current state - a back-dated row has
+     * an endsAt - and after the mutex is released, since it writes alert
+     * timelines. Fire-and-forget: it never fails or delays the state change.
+     */
+    if (!createdItem.endsAt && createdItem.projectId) {
+      IncidentAlertService.cascadeIncidentStateToLinkedAlerts({
+        projectId: createdItem.projectId,
+        incidentId: createdItem.incidentId,
+        incidentStateId: createdItem.incidentStateId,
+      }).catch((error: Error) => {
+        logger.error(
+          `Error while carrying the incident state over to linked alerts: ${error}`,
+          {
+            projectId: createdItem.projectId?.toString(),
+            incidentId: createdItem.incidentId?.toString(),
+          } as LogAttributes,
+        );
+      });
+    }
+
     const stateName: string = incidentState?.name || "";
     let stateEmoji: string = "➡️";
 

package/Server/Services/Index.ts

@@ -361,6 +361,7 @@ import IncidentEpisodeLabelRuleService from "./IncidentEpisodeLabelRuleService";
 import IncidentEpisodeFeedService from "./IncidentEpisodeFeedService";
 import IncidentEpisodeInternalNoteService from "./IncidentEpisodeInternalNoteService";
 import IncidentEpisodeMemberService from "./IncidentEpisodeMemberService";
+import IncidentAlertService from "./IncidentAlertService";
 import IncidentEpisodeRoleMemberService from "./IncidentEpisodeRoleMemberService";
 import IncidentEpisodeOwnerTeamService from "./IncidentEpisodeOwnerTeamService";
 import IncidentEpisodeOwnerRuleService from "./IncidentEpisodeOwnerRuleService";
@@ -797,6 +798,7 @@ const services: Array<BaseService> = [
   IncidentEpisodeFeedService,
   IncidentEpisodeInternalNoteService,
   IncidentEpisodeMemberService,
+  IncidentAlertService,
   IncidentEpisodeRoleMemberService,
   IncidentEpisodeOwnerTeamService,
   IncidentEpisodeOwnerRuleService,

package/Server/Utils/SessionReplay/SessionReplayGateCache.ts

@@ -90,6 +90,7 @@ const RUM_APPLICATION_POLICY_COLUMNS: ReadonlyArray<string> = [
   "sessionReplayMonthlyBudgetInGB",
   "sessionReplayIgnoreErrorPatterns",
   "sessionReplayTracePropagationOrigins",
+  "sessionReplaySameOriginTracePropagation",
   "sessionReplayLcpBudgetMs",
   "sessionReplayLongTaskBudgetMs",
   "sessionReplaySlowRequestBudgetMs",
@@ -159,11 +160,24 @@ export interface SessionReplayGatePolicy {
   ignoreErrorPatterns: Array<string>;
 
   /*
-   * Origins the recorder may inject a W3C traceparent header into.
-   * Empty = never inject; the empty default is the CORS safety mechanism.
+   * CROSS-origin APIs the recorder may inject a W3C traceparent header
+   * into (traceparent only, never the session id). Empty = no cross-origin
+   * injection; the empty default is the CORS safety mechanism. The page's
+   * own origin is governed by sameOriginTracePropagation, not by this list.
    */
   tracePropagationOrigins: Array<string>;
 
+  /*
+   * Whether the recorder adds traceparent plus a tracestate member carrying
+   * the replay session id to requests to the page's OWN origin while a
+   * session uploads, so the backend telemetry they cause links to the
+   * recording with no customer code. A same-origin request is never
+   * preflighted, so this defaults ON; the switch exists to turn it off
+   * without a customer redeploy (a same-origin request that redirects to
+   * another origin does need that origin to allow the headers).
+   */
+  sameOriginTracePropagation: boolean;
+
   /* Performance capture budgets in milliseconds; 0 disables each. */
   lcpBudgetMs: number;
   longTaskBudgetMs: number;
@@ -514,6 +528,14 @@ export default class SessionReplayGateCache {
         tracePropagationOrigins: this.readStringArray(
           appView["sessionReplayTracePropagationOrigins"],
         ),
+        /*
+         * Anything but an explicit false reads as on: the column defaults
+         * to true, so an absent or null value is the model default, like
+         * the consent / trigger / sample fallbacks above. Only an operator
+         * who switched it off gets it off.
+         */
+        sameOriginTracePropagation:
+          appView["sessionReplaySameOriginTracePropagation"] !== false,
         lcpBudgetMs: this.readNumber(appView["sessionReplayLcpBudgetMs"], 0),
         longTaskBudgetMs: this.readNumber(
           appView["sessionReplayLongTaskBudgetMs"],