@oneuptime/common 12.0.4 → 12.0.6

package/Server/Services/AlertService.ts

@@ -39,6 +39,7 @@ import { IsBillingEnabled } from "../EnvironmentConfig";
 import logger, { LogAttributes } from "../Utils/Logger";
 import Semaphore, { SemaphoreMutex } from "../Infrastructure/Semaphore";
 import TelemetryUtil from "../Utils/Telemetry/Telemetry";
+import MetricResourceAttributeUtil from "../../Utils/Metrics/MetricResourceAttributeUtil";
 import MutableMetricService from "./MutableMetricService";
 import GlobalConfigService from "./GlobalConfigService";
 import GlobalConfig from "../../Models/DatabaseModels/GlobalConfig";
@@ -1616,6 +1617,16 @@ ${alertSeverity.name}
           _id: true,
           name: true,
         },
+        /*
+         * A project's own taxonomy. Both become metric attributes below so
+         * dashboards can group MTTA/MTTR by the dimensions the project
+         * actually thinks in.
+         */
+        labels: {
+          _id: true,
+          name: true,
+        },
+        customFields: true,
       },
       props: {
         isRoot: true,
@@ -1692,6 +1703,29 @@ ${alertSeverity.name}
         metricRetentionDays,
       );
 
+      /*
+       * Dimensions shared by every alert metric. Built once so all four
+       * metrics below record the identical attribute set — a dashboard that
+       * groups by oneuptime.label.product must not find the dimension on
+       * AlertCount but missing from TimeToResolve.
+       */
+      const baseMetricAttributes: JSONObject = {
+        alertId: data.alertId.toString(),
+        projectId: alert.projectId.toString(),
+        monitorId: alert.monitor?._id?.toString(),
+        monitorName: alert.monitor?.name?.toString(),
+        alertSeverityId: alert.alertSeverity?._id?.toString(),
+        alertSeverityName: alert.alertSeverity?.name?.toString(),
+        /*
+         * oneuptime.label.* / oneuptime.customField.* — namespaced, so they can
+         * never collide with the unprefixed dimensions above.
+         */
+        ...MetricResourceAttributeUtil.getResourceAttributes({
+          labels: alert.labels,
+          customFields: alert.customFields,
+        }),
+      };
+
       // now we need to create new metrics for this alert - TimeToAcknowledge, TimeToResolve, AlertCount, AlertDuration
       const alertStartsAt: Date =
         firstAlertStateTimeline?.startsAt ||
@@ -1714,14 +1748,7 @@ ${alertSeverity.name}
       alertCountMetric.name = AlertMetricType.AlertCount;
       alertCountMetric.metricPointId = AlertMetricType.AlertCount;
       alertCountMetric.value = 1;
-      alertCountMetric.attributes = {
-        alertId: data.alertId.toString(),
-        projectId: alert.projectId.toString(),
-        monitorId: alert.monitor?._id?.toString(),
-        monitorName: alert.monitor?.name?.toString(),
-        alertSeverityId: alert.alertSeverity?._id?.toString(),
-        alertSeverityName: alert.alertSeverity?.name?.toString(),
-      };
+      alertCountMetric.attributes = { ...baseMetricAttributes };
       alertCountMetric.attributeKeys = TelemetryUtil.getAttributeKeys(
         alertCountMetric.attributes,
       );
@@ -1768,14 +1795,7 @@ ${alertSeverity.name}
             ackAlertStateTimeline?.startsAt || OneUptimeDate.getCurrentDate(),
             alertStartsAt,
           );
-          timeToAcknowledgeMetric.attributes = {
-            alertId: data.alertId.toString(),
-            projectId: alert.projectId.toString(),
-            monitorId: alert.monitor?._id?.toString(),
-            monitorName: alert.monitor?.name?.toString(),
-            alertSeverityId: alert.alertSeverity?._id?.toString(),
-            alertSeverityName: alert.alertSeverity?.name?.toString(),
-          };
+          timeToAcknowledgeMetric.attributes = { ...baseMetricAttributes };
           timeToAcknowledgeMetric.attributeKeys =
             TelemetryUtil.getAttributeKeys(timeToAcknowledgeMetric.attributes);
 
@@ -1825,14 +1845,7 @@ ${alertSeverity.name}
             OneUptimeDate.getCurrentDate(),
           alertStartsAt,
         );
-        timeToResolveMetric.attributes = {
-          alertId: data.alertId.toString(),
-          projectId: alert.projectId.toString(),
-          monitorId: alert.monitor?._id?.toString(),
-          monitorName: alert.monitor?.name?.toString(),
-          alertSeverityId: alert.alertSeverity?._id?.toString(),
-          alertSeverityName: alert.alertSeverity?.name?.toString(),
-        };
+        timeToResolveMetric.attributes = { ...baseMetricAttributes };
         timeToResolveMetric.attributeKeys = TelemetryUtil.getAttributeKeys(
           timeToResolveMetric.attributes,
         );
@@ -1872,14 +1885,7 @@ ${alertSeverity.name}
           alertEndsAt,
           alertStartsAt,
         );
-        alertDurationMetric.attributes = {
-          alertId: data.alertId.toString(),
-          projectId: alert.projectId.toString(),
-          monitorId: alert.monitor?._id?.toString(),
-          monitorName: alert.monitor?.name?.toString(),
-          alertSeverityId: alert.alertSeverity?._id?.toString(),
-          alertSeverityName: alert.alertSeverity?.name?.toString(),
-        };
+        alertDurationMetric.attributes = { ...baseMetricAttributes };
         alertDurationMetric.attributeKeys = TelemetryUtil.getAttributeKeys(
           alertDurationMetric.attributes,
         );

package/Server/Services/AnalyticsDatabaseService.ts

@@ -34,6 +34,7 @@ import {
   TimeoutOverflowMode,
 } from "../Utils/AnalyticsDatabase/QuerySettingsHelper";
 import {
+  getDistributedDdlTaskTimeoutSeconds,
   getStorageTableName,
   onClusterClause,
 } from "../Utils/AnalyticsDatabase/ClusterConfig";
@@ -137,6 +138,34 @@ export const MigrationExecuteOptions: ClickhouseExecuteOptions = {
      * migration pool's 30-minute idle ceiling.
      */
     http_headers_progress_interval_ms: "10000",
+    /*
+     * ON CLUSTER DDL is queued in Keeper and executed by each host's DDLWorker
+     * sequentially, so on a busy or backlogged cluster a host can be healthy
+     * yet not reach the task within the wait window. The server default output
+     * mode (`throw`) turns that into TIMEOUT_EXCEEDED (code 159) and aborts
+     * the whole migrate run — even though the task stays queued and the hosts
+     * execute it in the background (until the DDL queue evicts it:
+     * task_max_lifetime, one week, or falling more than max_tasks_in_queue
+     * entries behind). `null_status_on_timeout` returns NULL for the hosts
+     * that haven't finished yet instead of throwing, while a real DDL failure
+     * on any host that did run it within the window still throws. Safe because
+     * every schema statement here is idempotent (IF NOT EXISTS / OR REPLACE)
+     * and, with the default `distributed_ddl.pool_size = 1`, later DDL queues
+     * strictly behind earlier DDL on each host. Migrate.ts additionally warns
+     * at end of run when the DDL queue still has unfinished tasks. Note these
+     * options are also reused by runtime ALTER ... DELETE mutations (session
+     * erasure / pin materialization); timeout-as-success is acceptable there
+     * too since a mutation is durable once enqueued. Requires ClickHouse >=
+     * 21.4 (older servers reject the setting as unknown).
+     */
+    distributed_ddl_output_mode: "null_status_on_timeout",
+    /*
+     * Int64 settings are typed as strings by @clickhouse/client. Read at
+     * module load; env is static for the life of the process. The migration
+     * pool's socket-idle ceiling scales with this value (ClickhouseConfig.ts)
+     * so a raised wait isn't killed client-side.
+     */
+    distributed_ddl_task_timeout: String(getDistributedDdlTaskTimeoutSeconds()),
   },
 };
 
@@ -146,10 +175,14 @@ export const MigrationExecuteOptions: ClickhouseExecuteOptions = {
  * TelemetryFanInWriter can consume deterministic tokens without an import
  * cycle. Re-exported here for existing callers.
  *
- * HTTP-path inserts run outside the context and are always fire-and-forget
- * (wait_for_async_insert=0) — flush waiting, when opted into via
- * TELEMETRY_WAIT_FOR_ASYNC_INSERT, is only affordable off the request
- * thread and therefore only applies to tokened (queue-job) inserts.
+ * The ack mode is independent of tokening: TELEMETRY_WAIT_FOR_ASYNC_INSERT
+ * (shouldWaitForAsyncInsert below) is applied to EVERY insertJsonRows call,
+ * with or without a dedup token. Whether a telemetry queue job's writes
+ * carry per-job tokens from this context is a separate policy decided in
+ * the worker: the high-volume signals (traces/logs/metrics) run untokened
+ * so the fan-in writer can merge them into cross-job INSERTs under minted
+ * per-batch tokens — see shouldUseInsertDedup in
+ * App/FeatureSet/Telemetry/Jobs/TelemetryIngest/ProcessTelemetry.ts.
  */
 export {
   runWithInsertDedup,

package/Server/Services/DataSourceService.ts

@@ -0,0 +1,200 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/DataSource";
+import CreateBy from "../Types/Database/CreateBy";
+import UpdateBy from "../Types/Database/UpdateBy";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import DataSourceType, {
+  DataSourceTypeUtil,
+} from "../../Types/DataSource/DataSourceType";
+import { DataSourceConnectionSettings } from "../Utils/DataSource/Types";
+import Dictionary from "../../Types/Dictionary";
+import { JSONObject } from "../../Types/JSON";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  /*
+   * Per-type shape validation so a broken data source fails at save time
+   * with a clear message, not at first query with a connector error.
+   */
+  private validateDataSourceShape(data: {
+    dataSourceType?: DataSourceType | undefined;
+    url?: string | undefined;
+    databaseHost?: string | undefined;
+  }): void {
+    const dataSourceType: DataSourceType | undefined = data.dataSourceType;
+
+    if (!dataSourceType) {
+      return; // updates that don't touch the type/host/url skip validation.
+    }
+
+    if (!DataSourceTypeUtil.getAllDataSourceTypes().includes(dataSourceType)) {
+      throw new BadDataException(`Unknown data source type: ${dataSourceType}`);
+    }
+
+    if (DataSourceTypeUtil.isHttpBasedType(dataSourceType) && !data.url) {
+      throw new BadDataException(
+        `${dataSourceType} data sources require a URL.`,
+      );
+    }
+
+    if (
+      DataSourceTypeUtil.isDatabaseType(dataSourceType) &&
+      !data.databaseHost
+    ) {
+      throw new BadDataException(
+        `${dataSourceType} data sources require a database host.`,
+      );
+    }
+  }
+
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    this.validateDataSourceShape({
+      dataSourceType: createBy.data.dataSourceType,
+      url: createBy.data.url,
+      databaseHost: createBy.data.databaseHost,
+    });
+
+    return { createBy, carryForward: null };
+  }
+
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    /*
+     * Only validate when the update touches the fields that participate in
+     * shape validation. Changing the TYPE of an existing source without
+     * also sending url/host can produce a source that fails validation on
+     * its own merits — so when dataSourceType changes, re-validate against
+     * the stored row's values merged with the update.
+     */
+    const data: {
+      dataSourceType?: DataSourceType | undefined;
+      url?: string | undefined;
+      databaseHost?: string | undefined;
+    } = updateBy.data as unknown as {
+      dataSourceType?: DataSourceType | undefined;
+      url?: string | undefined;
+      databaseHost?: string | undefined;
+    };
+
+    /*
+     * Presence check, not truthiness — an update that CLEARS url or
+     * databaseHost (null / empty string) must still be validated, or an
+     * HTTP source could be stripped of its URL and break at query time.
+     */
+    const updateData: Record<string, unknown> = updateBy.data as Record<
+      string,
+      unknown
+    >;
+    const touchesShape: boolean =
+      "dataSourceType" in updateData ||
+      "url" in updateData ||
+      "databaseHost" in updateData;
+
+    if (touchesShape) {
+      const existing: Model | null = await this.findOneBy({
+        query: updateBy.query,
+        select: {
+          _id: true,
+          dataSourceType: true,
+          url: true,
+          databaseHost: true,
+        },
+        props: { isRoot: true },
+      });
+
+      /*
+       * A field present in the update wins even when cleared (null/"" →
+       * undefined, which validation treats as missing); an absent field
+       * falls back to the stored row.
+       */
+      this.validateDataSourceShape({
+        dataSourceType: data.dataSourceType || existing?.dataSourceType,
+        url: "url" in updateData ? data.url || undefined : existing?.url,
+        databaseHost:
+          "databaseHost" in updateData
+            ? data.databaseHost || undefined
+            : existing?.databaseHost,
+      });
+    }
+
+    return { updateBy, carryForward: null };
+  }
+
+  /*
+   * Decrypted connection settings for the server-side connector paths
+   * (/test and /query). ROOT read — the caller MUST have already performed
+   * a user-scoped access check on this id (the LlmProviderAPI two-phase
+   * pattern). The returned object holds plaintext secrets: never serialize
+   * it into a response or a log line.
+   */
+  @CaptureSpan()
+  public async getConnectionSettingsById(
+    dataSourceId: ObjectID,
+  ): Promise<DataSourceConnectionSettings | null> {
+    if (!ObjectID.isValidUUID(dataSourceId.toString())) {
+      /*
+       * A non-uuid string in a uuid column is a Postgres cast error, not
+       * an empty result — shape-check before querying.
+       */
+      return null;
+    }
+
+    const dataSource: Model | null = await this.findOneById({
+      id: dataSourceId,
+      select: {
+        _id: true,
+        projectId: true,
+        dataSourceType: true,
+        url: true,
+        databaseHost: true,
+        databasePort: true,
+        databaseName: true,
+        username: true,
+        password: true,
+        apiToken: true,
+        customHeaders: true,
+        additionalOptions: true,
+      },
+      props: { isRoot: true },
+    });
+
+    if (!dataSource || !dataSource.dataSourceType) {
+      return null;
+    }
+
+    let customHeaders: Dictionary<string> | undefined = undefined;
+    if (dataSource.customHeaders) {
+      customHeaders = {};
+      const headers: JSONObject = dataSource.customHeaders;
+      for (const key of Object.keys(headers)) {
+        if (headers[key] !== null && headers[key] !== undefined) {
+          customHeaders[key] = headers[key]!.toString();
+        }
+      }
+    }
+
+    return {
+      dataSourceType: dataSource.dataSourceType,
+      url: dataSource.url,
+      databaseHost: dataSource.databaseHost,
+      databasePort: dataSource.databasePort,
+      databaseName: dataSource.databaseName,
+      username: dataSource.username,
+      password: dataSource.password,
+      apiToken: dataSource.apiToken,
+      customHeaders: customHeaders,
+      additionalOptions: dataSource.additionalOptions,
+    };
+  }
+}
+
+export default new Service();

package/Server/Services/DatabaseService.ts

@@ -334,7 +334,8 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
    * generated — session refresh tokens and the like. They keep the fast
    * SHA-256 hash, which is the right tool for them: there is nothing to guess,
    * and they have to stay searchable by hash because that is how they are
-   * looked up.
+   * looked up. Every human-chosen credential, including dashboard and status
+   * page master passwords, declares a salt column and takes the scrypt path.
    *
    * The salt is written onto the SAME payload as the hash, so the pair can
    * never be persisted out of step with each other.
@@ -468,6 +469,10 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
             }),
             [saltColumnName]: newSalt,
           } as unknown as PartialEntity<TBaseModel>,
+          expectedData: {
+            [data.columnName]: storedHash,
+            [saltColumnName]: salt,
+          } as unknown as PartialEntity<TBaseModel>,
           skipUpdateDateColumn: true,
         });
       } catch (err) {
@@ -2502,6 +2507,14 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
   public async updateColumnsByIdWithoutHooks(input: {
     id: ObjectID;
     data: PartialEntity<TBaseModel>;
+    /*
+     * Optional compare-and-set guard. Every supplied property is added to
+     * the WHERE clause with null-safe equality, so the update is skipped if
+     * another writer changed the row after the caller read it. Password-hash
+     * upgrades use this to avoid overwriting a concurrently changed
+     * credential with a re-hash of the old password.
+     */
+    expectedData?: PartialEntity<TBaseModel>;
     /*
      * Leave `updatedAt` untouched. For passive bookkeeping writes (liveness
      * timestamps, ingest health markers) where consumers key change
@@ -2576,9 +2589,37 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
       metadata.primaryColumns[0]?.databaseName || "_id";
     params.push(input.id.toString());
 
+    const whereClauses: Array<string> = [
+      `"${primaryColumnName}" = $${params.length}`,
+    ];
+
+    for (const [propertyName, value] of Object.entries(
+      (input.expectedData || {}) as ObjectLiteral,
+    )) {
+      const column: ColumnMetadata | undefined =
+        metadata.findColumnWithPropertyName(propertyName);
+
+      if (!column) {
+        throw new BadDataException(
+          `updateColumnsByIdWithoutHooks: unknown expected column "${propertyName}" on "${metadata.tableName}"`,
+        );
+      }
+
+      if (typeof value === "function") {
+        throw new BadDataException(
+          `updateColumnsByIdWithoutHooks: SQL-expression expected values are not supported (column "${propertyName}"); pass a literal value.`,
+        );
+      }
+
+      params.push(driver.preparePersistentValue(value, column));
+      whereClauses.push(
+        `"${column.databaseName}" IS NOT DISTINCT FROM $${params.length}`,
+      );
+    }
+
     const sql: string = `UPDATE "${metadata.tableName}" SET ${setClauses.join(
       ", ",
-    )} WHERE "${primaryColumnName}" = $${params.length}`;
+    )} WHERE ${whereClauses.join(" AND ")}`;
 
     await repository.manager.query(sql, params);
   }

package/Server/Services/HostService.ts

@@ -11,6 +11,7 @@ import QueryHelper from "../Types/Database/QueryHelper";
 import OneUptimeDate from "../../Types/Date";
 import LIMIT_MAX from "../../Types/Database/LimitMax";
 import GlobalCache from "../Infrastructure/GlobalCache";
+import InProcessMemo from "../Utils/InProcessMemo";
 import logger, { LogAttributes } from "../Utils/Logger";
 import { canonicalizeEntityValue } from "../../Utils/Telemetry/EntityKey";
 import crypto from "crypto";
@@ -21,6 +22,46 @@ const LAST_SEEN_THROTTLE_SECONDS: number = 60;
 const LABELS_APPLIED_CACHE_NAMESPACE: string = "host-labels-applied";
 const LABELS_APPLIED_CACHE_TTL_SECONDS: number = 60;
 
+/*
+ * What `findOrCreateByHostIdentifier` memoizes: the resolved row's id plus
+ * the identifier it converged to. A flat shape rather than the Model itself
+ * so a memo hit hands every caller a FRESH Model instance — the resolving
+ * call and a memoed call must not share one mutable entity object.
+ */
+interface HostResolution {
+  hostIdStr: string;
+  hostIdentifier: string;
+}
+
+/*
+ * Per-process memo for `(projectId, canonical hostIdentifier) -> Host`.
+ *
+ * `findOrCreateByHostIdentifier` ran an unconditional Postgres SELECT per
+ * call, and the metrics ingest path calls it once per unique host per job
+ * (the host-enrichment aggregation loop) on top of `autoDiscoverHost`'s
+ * Redis-cache misses — for a fleet of workers chewing hostmetrics batches
+ * that is a steady stream of identical case-insensitive lookups for rows
+ * that change never. Same L1 shape as the service-resolution memo in
+ * OpenTelemetryIngestService: 60-second TTL, bounded because host
+ * identifiers arrive from collector-controlled resource attributes.
+ *
+ * ONLY positive resolutions (the host exists / was just created) are
+ * memoized, and only on success. There is deliberately no negative
+ * caching: the miss path must keep falling through to the create, so a
+ * create that loses a concurrent race still throws its unique-violation
+ * into the existing catch-and-refetch handling unchanged. Staleness is a
+ * non-issue for the id itself (ids are immutable); a deleted host keeps
+ * resolving for up to the TTL, which the 24-hour host-id Redis cache in
+ * OtelIngestBaseService already dwarfs.
+ */
+const HOST_RESOLUTION_MEMO_TTL_IN_MS: number = 60 * 1000;
+const HOST_RESOLUTION_MEMO_MAX_ENTRIES: number = 10_000;
+const hostResolutionInProcessMemo: InProcessMemo<HostResolution> =
+  new InProcessMemo<HostResolution>({
+    ttlInMs: HOST_RESOLUTION_MEMO_TTL_IN_MS,
+    maxEntries: HOST_RESOLUTION_MEMO_MAX_ENTRIES,
+  });
+
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
@@ -75,6 +116,24 @@ export class Service extends DatabaseService<Model> {
      */
     const hostIdentifier: string = canonicalizeEntityValue(data.hostIdentifier);
 
+    /*
+     * L1: in-process memo. The canonical identifier is the memo key, so
+     * every casing of one host collapses onto the entry the previous batch
+     * wrote — the same folding the SQL predicate below performs. A hit
+     * skips the SELECT (and the already-converged identifier write) that
+     * the resolving call performed within the last minute.
+     */
+    const memoKey: string = `${data.projectId.toString()}:${hostIdentifier}`;
+    const memoedResolution: HostResolution | undefined =
+      hostResolutionInProcessMemo.get(memoKey);
+    if (memoedResolution) {
+      const memoedHost: Model = new Model();
+      memoedHost._id = memoedResolution.hostIdStr;
+      memoedHost.projectId = data.projectId;
+      memoedHost.hostIdentifier = memoedResolution.hostIdentifier;
+      return memoedHost;
+    }
+
     /*
      * Look up case-insensitively. The unique guard on name/hostIdentifier
      * (DatabaseService.checkUniqueColumnBy -> QueryHelper.findWithSameText)
@@ -131,6 +190,18 @@ export class Service extends DatabaseService<Model> {
         }
       }
 
+      /*
+       * Memoize the identifier the row ACTUALLY holds (post-convergence,
+       * or the legacy casing when the best-effort update failed) so a memo
+       * hit returns exactly what a repeated lookup would have.
+       */
+      if (existingHost._id) {
+        hostResolutionInProcessMemo.set(memoKey, {
+          hostIdStr: existingHost._id.toString(),
+          hostIdentifier: existingHost.hostIdentifier || hostIdentifier,
+        });
+      }
+
       return existingHost;
     }
 
@@ -149,6 +220,13 @@ export class Service extends DatabaseService<Model> {
         },
       });
 
+      if (createdHost._id) {
+        hostResolutionInProcessMemo.set(memoKey, {
+          hostIdStr: createdHost._id.toString(),
+          hostIdentifier: hostIdentifier,
+        });
+      }
+
       return createdHost;
     } catch {
       /*
@@ -173,6 +251,20 @@ export class Service extends DatabaseService<Model> {
       });
 
       if (reFetchedHost) {
+        /*
+         * The refetch after a lost create race emits the same SELECT as
+         * the cold lookup, and a first-contact stampede on a brand-new
+         * host is exactly when this branch runs hot — memoize it like the
+         * other two resolution paths (mirrors the service-resolution
+         * cache's create-race handling).
+         */
+        if (reFetchedHost._id) {
+          hostResolutionInProcessMemo.set(memoKey, {
+            hostIdStr: reFetchedHost._id.toString(),
+            hostIdentifier: reFetchedHost.hostIdentifier || hostIdentifier,
+          });
+        }
+
         return reFetchedHost;
       }
 

package/Server/Services/IncidentFeedService.ts

@@ -84,6 +84,7 @@ export class Service extends DatabaseService<IncidentFeed> {
     displayColor?: Color | undefined;
     userId?: ObjectID | undefined;
     postedAt?: Date | undefined;
+    aiRunId?: ObjectID | undefined;
     // send notifificatin to slack and teams. This is optional
     workspaceNotification?:
       | {
@@ -131,6 +132,10 @@ export class Service extends DatabaseService<IncidentFeed> {
       incidentFeed.incidentFeedEventType = data.incidentFeedEventType;
       incidentFeed.projectId = data.projectId;
 
+      if (data.aiRunId) {
+        incidentFeed.aiRunId = data.aiRunId;
+      }
+
       if (!data.postedAt) {
         incidentFeed.postedAt = OneUptimeDate.getCurrentDate();
       }