@oneuptime/common 10.0.88 → 10.0.89

package/Server/API/MetricAPI.ts

@@ -0,0 +1,149 @@
+import AggregateBy from "../../Types/BaseDatabase/AggregateBy";
+import AggregatedResult from "../../Types/BaseDatabase/AggregatedResult";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import BadRequestException from "../../Types/Exception/BadRequestException";
+import { JSONObject } from "../../Types/JSON";
+import JSONFunctions from "../../Types/JSONFunctions";
+import Metric from "../../Models/AnalyticsModels/Metric";
+import { MetricService } from "../Services/MetricService";
+import GlobalCache from "../Infrastructure/GlobalCache";
+import logger from "../Utils/Logger";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import { ExpressRequest, ExpressResponse } from "../Utils/Express";
+import Response from "../Utils/Response";
+import CommonAPI from "./CommonAPI";
+import BaseAnalyticsAPI from "./BaseAnalyticsAPI";
+
+/*
+ * Aggregate cache TTL. Dashboards typically auto-refresh every 30s+, so
+ * an 8s window collapses bursts of identical requests (e.g. 12 widgets
+ * loading on the same page) onto a single ClickHouse query while still
+ * looking real-time to humans.
+ */
+const AGGREGATE_CACHE_NAMESPACE: string = "metric-aggregate";
+const AGGREGATE_CACHE_TTL_SECONDS: number = 8;
+
+export default class MetricAPI extends BaseAnalyticsAPI<Metric, MetricService> {
+  public constructor(service: MetricService) {
+    super(Metric, service);
+  }
+
+  /*
+   * Cached override of BaseAnalyticsAPI.getAggregate.
+   *
+   * Why a cache: each chart/value/gauge/table widget on a dashboard
+   * issues its own /aggregate call. With 10+ widgets and a small group
+   * of users hitting the same dashboard the underlying ClickHouse
+   * cluster sees the same heavy aggregation many times in close
+   * succession. Aggregations are read-only and pure (same input ->
+   * same output for the bucket interval), so a brief result cache is
+   * safe.
+   *
+   * Cache key: tenant project + the deserialized aggregateBy payload.
+   * We must include the project so cross-tenant collisions cannot
+   * leak data; we deliberately do NOT key on user id, because the
+   * service layer applies project-scoped read permissions and metric
+   * data is project-wide.
+   *
+   * Cache miss / Redis down: we fall through to the live query, so
+   * cache outages degrade to today's behavior, never error.
+   */
+  @CaptureSpan()
+  public override async getAggregate(
+    req: ExpressRequest,
+    res: ExpressResponse,
+  ): Promise<void> {
+    await this.onBeforeList(req, res);
+
+    let aggregateBy: AggregateBy<Metric> | null = null;
+
+    if (req.body && req.body["aggregateBy"]) {
+      aggregateBy = JSONFunctions.deserialize(
+        req.body["aggregateBy"] as JSONObject,
+      ) as any;
+    }
+
+    if (!aggregateBy) {
+      throw new BadRequestException("AggregateBy is required");
+    }
+
+    const databaseProps: DatabaseCommonInteractionProps =
+      await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+    const projectId: string | undefined = databaseProps.tenantId?.toString();
+    const cacheKey: string | null = projectId
+      ? `${projectId}:${this.buildCacheKey(aggregateBy)}`
+      : null;
+
+    if (cacheKey) {
+      try {
+        const cached: JSONObject | null = await GlobalCache.getJSONObject(
+          AGGREGATE_CACHE_NAMESPACE,
+          cacheKey,
+        );
+        if (cached) {
+          return Response.sendJsonObjectResponse(req, res, cached);
+        }
+      } catch (err) {
+        // Cache fetch failed — fall through to a live query.
+        logger.debug("MetricAPI aggregate cache read failed");
+        logger.debug(err);
+      }
+    }
+
+    const aggregateResult: AggregatedResult = await this.service.aggregateBy({
+      ...aggregateBy,
+      props: databaseProps,
+    });
+
+    const responseBody: JSONObject = { ...(aggregateResult as any) };
+
+    if (cacheKey) {
+      try {
+        await GlobalCache.setJSON(
+          AGGREGATE_CACHE_NAMESPACE,
+          cacheKey,
+          responseBody,
+          { expiresInSeconds: AGGREGATE_CACHE_TTL_SECONDS },
+        );
+      } catch (err) {
+        logger.debug("MetricAPI aggregate cache write failed");
+        logger.debug(err);
+      }
+    }
+
+    return Response.sendJsonObjectResponse(req, res, responseBody);
+  }
+
+  private buildCacheKey(aggregateBy: AggregateBy<Metric>): string {
+    /*
+     * Stable serialization. Date instances are normalized to ISO so two
+     * logically-equal time windows hit the same cache slot, and we sort
+     * keys via JSON.stringify replacer to keep ordering deterministic
+     * across clients and across versions of V8.
+     */
+    return JSON.stringify(
+      aggregateBy,
+      (_key: string, value: unknown): unknown => {
+        if (value instanceof Date) {
+          return value.toISOString();
+        }
+        if (
+          value &&
+          typeof value === "object" &&
+          !Array.isArray(value) &&
+          (value as Record<string, unknown>).constructor === Object
+        ) {
+          const sorted: Record<string, unknown> = {};
+          for (const k of Object.keys(
+            value as Record<string, unknown>,
+          ).sort()) {
+            sorted[k] = (value as Record<string, unknown>)[k];
+          }
+          return sorted;
+        }
+        return value;
+      },
+    );
+  }
+}

package/Server/Services/AnalyticsDatabaseService.ts

@@ -787,6 +787,27 @@ export default class AnalyticsDatabaseService<
     }}
         `);
 
+    /*
+     * Aggregation read-path settings.
+     *
+     * - optimize_aggregation_in_order: when GROUP BY is a prefix of the
+     *   sort key (we always group by a time bucket and the time column
+     *   is at the tail of every analytics primary key), ClickHouse can
+     *   stream rows in order and emit aggregates without an in-memory
+     *   sort, which is a large speedup on wide time ranges.
+     * - optimize_move_to_prewhere: PREWHERE is a default-on optimizer
+     *   pass; we set it explicitly so the behavior is independent of
+     *   server-side defaults.
+     * - max_threads=4: caps per-query parallelism so a single dashboard
+     *   load (which fans out to many aggregate calls) does not starve
+     *   other tenants on the cluster. Per-query latency is essentially
+     *   unchanged at 4 threads for the usual dashboard widget time
+     *   ranges, but cluster headroom is preserved under burst.
+     */
+    statement.append(
+      ` SETTINGS optimize_aggregation_in_order=1, optimize_move_to_prewhere=1, max_threads=4`,
+    );
+
     logger.debug(`${this.model.tableName} Aggregate Statement`, { tableName: this.model.tableName } as LogAttributes);
     logger.debug(statement, { tableName: this.model.tableName } as LogAttributes);
 

package/Server/Services/MetricService.ts

@@ -5,10 +5,11 @@ import AggregateBy, {
   AggregateUtil,
 } from "../Types/AnalyticsDatabase/AggregateBy";
 import { SQL, Statement } from "../Utils/AnalyticsDatabase/Statement";
-import {
+import AggregationType, {
   getPercentileLevel,
   isPercentileAggregation,
 } from "../../Types/BaseDatabase/AggregationType";
+import AggregationInterval from "../../Types/BaseDatabase/AggregationInterval";
 import TableColumnType from "../../Types/AnalyticsDatabase/TableColumnType";
 import logger, { LogAttributes } from "../Utils/Logger";
 
@@ -56,6 +57,13 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
     columns: Array<string>;
   } {
     if (!isPercentileAggregation(aggregateBy.aggregationType)) {
+      const mvStatement: {
+        statement: Statement;
+        columns: Array<string>;
+      } | null = this.tryBuildMinuteAggregateMVStatement(aggregateBy);
+      if (mvStatement) {
+        return mvStatement;
+      }
       return super.toAggregateStatement(aggregateBy);
     }
 
@@ -216,6 +224,16 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
       }} `,
     );
 
+    /*
+     * Match the read-path settings the base aggregator now appends (see
+     * AnalyticsDatabaseService.toAggregateStatement). The percentile
+     * path bypasses the base method, so we mirror them here to keep
+     * cluster behavior consistent across aggregation kinds.
+     */
+    statement.append(
+      ` SETTINGS optimize_aggregation_in_order=1, optimize_move_to_prewhere=1, max_threads=4`,
+    );
+
     const columns: Array<string> = [
       aggregationColumn,
       aggregationTimestampColumn,
@@ -231,6 +249,180 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
 
     return { statement, columns };
   }
+
+  /*
+   * Materialized-view fast path for scalar aggregations.
+   *
+   * Returns a statement that reads from MetricItemAggMV1m (the
+   * 1-minute pre-aggregate created by
+   * AddMetricMinuteAggregateMaterializedView) when:
+   *
+   *   - The aggregation is Sum/Avg/Min/Max/Count over `value`.
+   *   - The dashboard's effective bucket interval is >= 1 minute (the
+   *     MV stores 1-minute states; sub-minute requests need raw rows).
+   *   - The query carries no per-attribute filter or group-by, since
+   *     the MV is keyed by (projectId, name, serviceId, bucketTime)
+   *     only — it does not preserve attribute breakdowns.
+   *   - The query carries no group-by other than the time bucket.
+   *
+   * Returns `null` if any condition fails so the caller falls back to
+   * the base table. The result row shape (columns: aggregateColumn,
+   * timestampColumn) matches the base statement so downstream code
+   * needs no changes.
+   */
+  private tryBuildMinuteAggregateMVStatement(
+    aggregateBy: AggregateBy<Metric>,
+  ): { statement: Statement; columns: Array<string> } | null {
+    const aggType: AggregationType = aggregateBy.aggregationType;
+    const supported: ReadonlyArray<AggregationType> = [
+      AggregationType.Sum,
+      AggregationType.Avg,
+      AggregationType.Min,
+      AggregationType.Max,
+      AggregationType.Count,
+    ];
+    if (!supported.includes(aggType)) {
+      return null;
+    }
+
+    if (
+      aggregateBy.aggregateColumnName.toString() !== "value" ||
+      aggregateBy.aggregationTimestampColumnName.toString() !== "time"
+    ) {
+      return null;
+    }
+
+    const interval: AggregationInterval = AggregateUtil.getAggregationInterval({
+      startDate: aggregateBy.startTimestamp!,
+      endDate: aggregateBy.endTimestamp!,
+    });
+    /*
+     * The MV is bucketed at 1 minute, so all values of AggregationInterval
+     * (Minute / Hour / Day / Week / Month / Year) are >= MV resolution
+     * and acceptable. Kept as a no-op read so the dependency on
+     * AggregateUtil makes the intent obvious.
+     */
+    void interval;
+
+    const queryRecord: Record<string, unknown> =
+      (aggregateBy.query as unknown as Record<string, unknown>) || {};
+    const attrs: unknown = queryRecord["attributes"];
+    if (
+      attrs !== undefined &&
+      attrs !== null &&
+      !(
+        typeof attrs === "object" &&
+        Object.keys(attrs as Record<string, unknown>).length === 0
+      )
+    ) {
+      return null;
+    }
+
+    if (aggregateBy.groupBy && Object.keys(aggregateBy.groupBy).length > 0) {
+      return null;
+    }
+
+    if (!this.database) {
+      this.useDefaultDatabase();
+    }
+    const databaseName: string = this.database.getDatasourceOptions().database!;
+
+    const intervalLower: string = interval.toLowerCase();
+
+    let mergedExpr: string;
+    if (aggType === AggregationType.Sum) {
+      mergedExpr = `sumMerge(valueSumState)`;
+    } else if (aggType === AggregationType.Count) {
+      mergedExpr = `countMerge(valueCountState)`;
+    } else if (aggType === AggregationType.Min) {
+      mergedExpr = `minMerge(valueMinState)`;
+    } else if (aggType === AggregationType.Max) {
+      mergedExpr = `maxMerge(valueMaxState)`;
+    } else {
+      // Avg = sum / count, derived from the two stored states.
+      mergedExpr = `if(countMerge(valueCountState) = 0, 0, sumMerge(valueSumState) / countMerge(valueCountState))`;
+    }
+
+    /*
+     * Build the WHERE on a copy of the query with `time` removed so
+     * the generator never references a column that doesn't exist on
+     * the MV. We then add an explicit `bucketTime` range from
+     * startTimestamp/endTimestamp.
+     */
+    const nonTimeWhere: Statement = this.statementGenerator.toWhereStatement(
+      this.stripTimeFromQuery(aggregateBy.query) as typeof aggregateBy.query,
+    );
+    const sortStatement: Statement = this.statementGenerator.toSortStatement(
+      aggregateBy.sort!,
+    );
+
+    const statement: Statement = SQL``;
+
+    statement.append(
+      `SELECT ${mergedExpr} as value, date_trunc('${intervalLower}', toStartOfInterval(bucketTime, INTERVAL 1 ${intervalLower})) as time`,
+    );
+    statement.append(SQL` FROM ${databaseName}.MetricItemAggMV1m`);
+    statement.append(
+      ` WHERE bucketTime >= toDateTime('${this.formatDateTime(aggregateBy.startTimestamp!)}') AND bucketTime <= toDateTime('${this.formatDateTime(aggregateBy.endTimestamp!)}')`,
+    );
+    statement.append(SQL` `).append(nonTimeWhere);
+
+    statement.append(SQL` GROUP BY `).append(`time`);
+    statement.append(SQL` ORDER BY `).append(sortStatement);
+    statement.append(
+      SQL` LIMIT ${{
+        value: Number(aggregateBy.limit),
+        type: TableColumnType.Number,
+      }}`,
+    );
+    statement.append(
+      SQL` OFFSET ${{
+        value: Number(aggregateBy.skip),
+        type: TableColumnType.Number,
+      }} `,
+    );
+    statement.append(
+      ` SETTINGS optimize_aggregation_in_order=1, optimize_move_to_prewhere=1, max_threads=4`,
+    );
+
+    logger.debug(`${this.model.tableName} MV Aggregate Statement`, {
+      tableName: this.model.tableName,
+    } as LogAttributes);
+    logger.debug(statement, {
+      tableName: this.model.tableName,
+    } as LogAttributes);
+
+    return {
+      statement,
+      columns: [
+        aggregateBy.aggregateColumnName.toString(),
+        aggregateBy.aggregationTimestampColumnName.toString(),
+      ],
+    };
+  }
+
+  private stripTimeFromQuery(query: unknown): typeof query {
+    if (!query || typeof query !== "object") {
+      return query;
+    }
+    const out: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(query as Record<string, unknown>)) {
+      if (k === "time") {
+        continue;
+      }
+      out[k] = v;
+    }
+    return out as typeof query;
+  }
+
+  private formatDateTime(d: Date): string {
+    /*
+     * ClickHouse's DateTime parser accepts 'YYYY-MM-DD HH:MM:SS'.
+     * toISOString gives 'YYYY-MM-DDTHH:MM:SS.sssZ'; trim the milliseconds
+     * and the trailing 'Z' and replace 'T' with a space.
+     */
+    return new Date(d).toISOString().replace("T", " ").substring(0, 19);
+  }
 }
 
 export default new MetricService();

package/Types/Dashboard/DashboardComponentType.ts

@@ -6,6 +6,9 @@ enum DashboardComponentType {
   Gauge = `Gauge`,
   LogStream = `LogStream`,
   TraceList = `TraceList`,
+  IncidentList = `IncidentList`,
+  AlertList = `AlertList`,
+  MonitorList = `MonitorList`,
 }
 
 export default DashboardComponentType;

package/Types/Dashboard/DashboardComponents/DashboardAlertListComponent.ts

@@ -0,0 +1,13 @@
+import ObjectID from "../../ObjectID";
+import DashboardComponentType from "../DashboardComponentType";
+import BaseComponent from "./DashboardBaseComponent";
+
+export default interface DashboardAlertListComponent extends BaseComponent {
+  componentType: DashboardComponentType.AlertList;
+  componentId: ObjectID;
+  arguments: {
+    title?: string | undefined;
+    maxRows?: number | undefined;
+    stateFilter?: string | undefined;
+  };
+}

package/Types/Dashboard/DashboardComponents/DashboardIncidentListComponent.ts

@@ -0,0 +1,13 @@
+import ObjectID from "../../ObjectID";
+import DashboardComponentType from "../DashboardComponentType";
+import BaseComponent from "./DashboardBaseComponent";
+
+export default interface DashboardIncidentListComponent extends BaseComponent {
+  componentType: DashboardComponentType.IncidentList;
+  componentId: ObjectID;
+  arguments: {
+    title?: string | undefined;
+    maxRows?: number | undefined;
+    stateFilter?: string | undefined;
+  };
+}

package/Types/Dashboard/DashboardComponents/DashboardMonitorListComponent.ts

@@ -0,0 +1,13 @@
+import ObjectID from "../../ObjectID";
+import DashboardComponentType from "../DashboardComponentType";
+import BaseComponent from "./DashboardBaseComponent";
+
+export default interface DashboardMonitorListComponent extends BaseComponent {
+  componentType: DashboardComponentType.MonitorList;
+  componentId: ObjectID;
+  arguments: {
+    title?: string | undefined;
+    maxRows?: number | undefined;
+    statusFilter?: string | undefined;
+  };
+}

package/Types/JSONFunctions.ts

@@ -20,7 +20,67 @@ export default class JSONFunctions {
     obj1: GenericObject,
     obj2: GenericObject,
   ): boolean {
-    return JSON.stringify(obj1) !== JSON.stringify(obj2);
+    return !JSONFunctions.deepEqual(obj1, obj2);
+  }
+
+  /*
+   * Structural deep-equal that short-circuits at the first mismatch. The
+   * dashboard widget hot path was previously running JSON.stringify on
+   * both sides of nested metricQueryConfig objects every render, which
+   * dominated CPU when many widgets were on screen. This visits the
+   * tree once and bails on the first divergence.
+   */
+  public static deepEqual(a: unknown, b: unknown): boolean {
+    if (a === b) {
+      return true;
+    }
+
+    if (
+      a === null ||
+      b === null ||
+      typeof a !== "object" ||
+      typeof b !== "object"
+    ) {
+      return false;
+    }
+
+    if (a instanceof Date || b instanceof Date) {
+      return (
+        a instanceof Date && b instanceof Date && a.getTime() === b.getTime()
+      );
+    }
+
+    if (Array.isArray(a) || Array.isArray(b)) {
+      if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) {
+        return false;
+      }
+      for (let i: number = 0; i < a.length; i++) {
+        if (!JSONFunctions.deepEqual(a[i], b[i])) {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    const keysA: Array<string> = Object.keys(a as Record<string, unknown>);
+    const keysB: Array<string> = Object.keys(b as Record<string, unknown>);
+    if (keysA.length !== keysB.length) {
+      return false;
+    }
+    for (const key of keysA) {
+      if (!Object.prototype.hasOwnProperty.call(b, key)) {
+        return false;
+      }
+      if (
+        !JSONFunctions.deepEqual(
+          (a as Record<string, unknown>)[key],
+          (b as Record<string, unknown>)[key],
+        )
+      ) {
+        return false;
+      }
+    }
+    return true;
   }
 
   public static nestJson(obj: JSONObject): JSONObject {

package/Utils/Dashboard/Components/DashboardAlertListComponent.ts

@@ -0,0 +1,86 @@
+import DashboardAlertListComponent from "../../../Types/Dashboard/DashboardComponents/DashboardAlertListComponent";
+import { ObjectType } from "../../../Types/JSON";
+import ObjectID from "../../../Types/ObjectID";
+import DashboardBaseComponentUtil from "./DashboardBaseComponent";
+import {
+  ComponentArgument,
+  ComponentArgumentSection,
+  ComponentInputType,
+} from "../../../Types/Dashboard/DashboardComponents/ComponentArgument";
+import DashboardComponentType from "../../../Types/Dashboard/DashboardComponentType";
+
+const DisplaySection: ComponentArgumentSection = {
+  name: "Display Options",
+  description: "Configure the widget title and row limit",
+  order: 1,
+};
+
+const FiltersSection: ComponentArgumentSection = {
+  name: "Filters",
+  description: "Narrow down which alerts are shown",
+  order: 2,
+  defaultCollapsed: true,
+};
+
+export default class DashboardAlertListComponentUtil extends DashboardBaseComponentUtil {
+  public static override getDefaultComponent(): DashboardAlertListComponent {
+    return {
+      _type: ObjectType.DashboardComponent,
+      componentType: DashboardComponentType.AlertList,
+      widthInDashboardUnits: 6,
+      heightInDashboardUnits: 4,
+      topInDashboardUnits: 0,
+      leftInDashboardUnits: 0,
+      componentId: ObjectID.generate(),
+      minHeightInDashboardUnits: 3,
+      minWidthInDashboardUnits: 6,
+      arguments: {
+        maxRows: 25,
+      },
+    };
+  }
+
+  public static override getComponentConfigArguments(): Array<
+    ComponentArgument<DashboardAlertListComponent>
+  > {
+    const componentArguments: Array<
+      ComponentArgument<DashboardAlertListComponent>
+    > = [];
+
+    componentArguments.push({
+      name: "Title",
+      description: "Header shown above the alert list",
+      required: false,
+      type: ComponentInputType.Text,
+      id: "title",
+      section: DisplaySection,
+    });
+
+    componentArguments.push({
+      name: "Max Rows",
+      description: "Maximum number of alerts to show",
+      required: false,
+      type: ComponentInputType.Number,
+      id: "maxRows",
+      placeholder: "25",
+      section: DisplaySection,
+    });
+
+    componentArguments.push({
+      name: "State",
+      description: "Filter alerts by lifecycle state",
+      required: false,
+      type: ComponentInputType.Dropdown,
+      id: "stateFilter",
+      section: FiltersSection,
+      dropdownOptions: [
+        { label: "All", value: "" },
+        { label: "Unresolved (open)", value: "unresolved" },
+        { label: "Acknowledged", value: "acknowledged" },
+        { label: "Resolved", value: "resolved" },
+      ],
+    });
+
+    return componentArguments;
+  }
+}

package/Utils/Dashboard/Components/DashboardIncidentListComponent.ts

@@ -0,0 +1,86 @@
+import DashboardIncidentListComponent from "../../../Types/Dashboard/DashboardComponents/DashboardIncidentListComponent";
+import { ObjectType } from "../../../Types/JSON";
+import ObjectID from "../../../Types/ObjectID";
+import DashboardBaseComponentUtil from "./DashboardBaseComponent";
+import {
+  ComponentArgument,
+  ComponentArgumentSection,
+  ComponentInputType,
+} from "../../../Types/Dashboard/DashboardComponents/ComponentArgument";
+import DashboardComponentType from "../../../Types/Dashboard/DashboardComponentType";
+
+const DisplaySection: ComponentArgumentSection = {
+  name: "Display Options",
+  description: "Configure the widget title and row limit",
+  order: 1,
+};
+
+const FiltersSection: ComponentArgumentSection = {
+  name: "Filters",
+  description: "Narrow down which incidents are shown",
+  order: 2,
+  defaultCollapsed: true,
+};
+
+export default class DashboardIncidentListComponentUtil extends DashboardBaseComponentUtil {
+  public static override getDefaultComponent(): DashboardIncidentListComponent {
+    return {
+      _type: ObjectType.DashboardComponent,
+      componentType: DashboardComponentType.IncidentList,
+      widthInDashboardUnits: 6,
+      heightInDashboardUnits: 4,
+      topInDashboardUnits: 0,
+      leftInDashboardUnits: 0,
+      componentId: ObjectID.generate(),
+      minHeightInDashboardUnits: 3,
+      minWidthInDashboardUnits: 6,
+      arguments: {
+        maxRows: 25,
+      },
+    };
+  }
+
+  public static override getComponentConfigArguments(): Array<
+    ComponentArgument<DashboardIncidentListComponent>
+  > {
+    const componentArguments: Array<
+      ComponentArgument<DashboardIncidentListComponent>
+    > = [];
+
+    componentArguments.push({
+      name: "Title",
+      description: "Header shown above the incident list",
+      required: false,
+      type: ComponentInputType.Text,
+      id: "title",
+      section: DisplaySection,
+    });
+
+    componentArguments.push({
+      name: "Max Rows",
+      description: "Maximum number of incidents to show",
+      required: false,
+      type: ComponentInputType.Number,
+      id: "maxRows",
+      placeholder: "25",
+      section: DisplaySection,
+    });
+
+    componentArguments.push({
+      name: "State",
+      description: "Filter incidents by lifecycle state",
+      required: false,
+      type: ComponentInputType.Dropdown,
+      id: "stateFilter",
+      section: FiltersSection,
+      dropdownOptions: [
+        { label: "All", value: "" },
+        { label: "Unresolved (open)", value: "unresolved" },
+        { label: "Acknowledged", value: "acknowledged" },
+        { label: "Resolved", value: "resolved" },
+      ],
+    });
+
+    return componentArguments;
+  }
+}