@oneuptime/common 11.0.14 → 11.1.1

package/Server/Utils/AnalyticsDatabase/StatementGenerator.ts

@@ -6,6 +6,13 @@ import Sort from "../../Types/AnalyticsDatabase/Sort";
 import UpdateBy from "../../Types/AnalyticsDatabase/UpdateBy";
 import logger from "../Logger";
 import { SQL, Statement } from "./Statement";
+import {
+  adaptTableSettingsForStorage,
+  getDistributedEngine,
+  getStorageEngine,
+  getStorageTableName,
+  onClusterClause,
+} from "./ClusterConfig";
 import AnalyticsBaseModel from "../../../Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
 import CommonModel, {
   Record as AnalyticsRecord,
@@ -78,12 +85,24 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
     const setStatement: Statement = this.toSetStatement(updateBy.data);
     const whereStatement: Statement = this.toWhereStatement(updateBy.query);
 
+    /*
+     * `ALTER TABLE … UPDATE` is a mutation and cannot target a Distributed
+     * table, so in cluster mode it runs against the local storage table and is
+     * dispatched to every shard via ON CLUSTER (replicated within each shard by
+     * Keeper). onClusterClause() is appended as RAW SQL — it is not an
+     * identifier and must not become a {pN:Identifier} parameter — and is empty
+     * in single-node mode, leaving the original statement unchanged.
+     */
     /* eslint-disable prettier/prettier */
     const statement: Statement = SQL`
-            ALTER TABLE ${this.database.getDatasourceOptions().database!}.${
-              this.model.tableName
-            }
-            UPDATE `
+            ALTER TABLE ${this.database.getDatasourceOptions().database!}.${getStorageTableName(
+              this.model.tableName,
+            )}`
+      .append(onClusterClause())
+      .append(
+        SQL`
+            UPDATE `,
+      )
       .append(setStatement)
       .append(
         SQL`
@@ -1089,9 +1108,9 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
   ): Promise<Statement> {
     const statement: string = `ALTER TABLE ${
       this.database.getDatasourceOptions().database
-    }.${
-      this.model.tableName
-    } RENAME COLUMN IF EXISTS ${oldColumnName} TO ${newColumnName}`;
+    }.${getStorageTableName(
+      this.model.tableName,
+    )} RENAME COLUMN IF EXISTS ${oldColumnName} TO ${newColumnName}`;
 
     return SQL`${statement}`;
   }
@@ -1309,9 +1328,9 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
     }
 
     const statement: Statement = SQL`
-            ALTER TABLE ${this.database.getDatasourceOptions().database!}.${
-              this.model.tableName
-            } ADD COLUMN IF NOT EXISTS `.append(columnDef);
+            ALTER TABLE ${this.database.getDatasourceOptions().database!}.${getStorageTableName(
+              this.model.tableName,
+            )} ADD COLUMN IF NOT EXISTS `.append(columnDef);
 
     logger.debug(`${this.model.tableName} Add Column Statement`);
     logger.debug(statement);
@@ -1341,7 +1360,7 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
     const databaseName: string = this.database.getDatasourceOptions().database!;
     const statement: Statement = new Statement();
     statement.append(
-      `ALTER TABLE ${databaseName}.${this.model.tableName} ADD INDEX IF NOT EXISTS ${idx.name} ${columnExpr} TYPE ${idx.type}${paramsStr} GRANULARITY ${idx.granularity}`,
+      `ALTER TABLE ${databaseName}.${getStorageTableName(this.model.tableName)} ADD INDEX IF NOT EXISTS ${idx.name} ${columnExpr} TYPE ${idx.type}${paramsStr} GRANULARITY ${idx.granularity}`,
     );
 
     logger.debug(`${this.model.tableName} Add Skip Index Statement`);
@@ -1352,7 +1371,7 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
 
   public toDropSkipIndexStatement(indexName: string): string {
     const databaseName: string = this.database.getDatasourceOptions().database!;
-    const statement: string = `ALTER TABLE ${databaseName}.${this.model.tableName} DROP INDEX IF EXISTS ${indexName}`;
+    const statement: string = `ALTER TABLE ${databaseName}.${getStorageTableName(this.model.tableName)} DROP INDEX IF EXISTS ${indexName}`;
 
     logger.debug(`${this.model.tableName} Drop Skip Index Statement`);
     logger.debug(statement);
@@ -1362,7 +1381,9 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
 
   public toDropColumnStatement(columnName: string): string {
     const statement: string = `ALTER TABLE ${this.database.getDatasourceOptions()
-      .database!}.${this.model.tableName} DROP COLUMN IF EXISTS ${columnName}`;
+      .database!}.${getStorageTableName(
+      this.model.tableName,
+    )} DROP COLUMN IF EXISTS ${columnName}`;
 
     logger.debug(`${this.model.tableName} Drop Column Statement`);
     logger.debug(statement);
@@ -1377,16 +1398,40 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
     );
 
     /*
-     * special case - ClickHouse does not support using a query parameter
-     * to specify the table engine
+     * special case - ClickHouse does not support using a query parameter to
+     * specify the table name, engine, or ON CLUSTER clause, so these are
+     * interpolated as raw SQL (the SQL tag only parameterizes ${{value,type}}
+     * objects, not plain string interpolations).
+     *
+     * In cluster mode this builds the LOCAL storage table
+     * (`<tableName>Local` with a Replicated* engine) `ON CLUSTER '<name>'`; the
+     * app-facing Distributed table is created separately via
+     * toDistributedTableCreateStatement(). In single-node mode it builds the
+     * model's own table with its plain engine, exactly as before.
      */
-    const tableEngineStatement: string = this.model.tableEngine;
+    const tableEngineStatement: string = getStorageEngine(
+      this.model.tableEngine,
+    );
+
+    const storageTableName: string = getStorageTableName(this.model.tableName);
+
+    const onCluster: string = onClusterClause();
 
     const partitionKey: string = this.model.partitionKey;
 
     const statement: Statement = SQL`
-            CREATE TABLE IF NOT EXISTS ${databaseName}.${this.model.tableName}
-            (\n`
+            CREATE TABLE IF NOT EXISTS ${databaseName}.${storageTableName}`
+      /*
+       * ON CLUSTER is appended as RAW SQL — the SQL tag turns every ${..}
+       * interpolation into a {pN:Identifier} parameter, which would wrongly
+       * quote the whole " ON CLUSTER '<name>'" clause as a single identifier.
+       * onCluster is "" in single-node mode, so this is a no-op there.
+       */
+      .append(onCluster)
+      .append(
+        SQL`
+            (\n`,
+      )
       .append(columnsStatement)
       .append(
         SQL`
@@ -1426,10 +1471,15 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
 
     /*
      * Append table-level SETTINGS if specified (e.g. ttl_only_drop_parts = 1
-     * so TTL drops whole time-partitions instead of rewriting parts).
+     * so TTL drops whole time-partitions instead of rewriting parts). In
+     * cluster mode the non-replicated dedup window is rewritten to its
+     * replicated equivalent so insert idempotency survives.
      */
-    if (this.model.tableSettings) {
-      statement.append(`\nSETTINGS ${this.model.tableSettings}`);
+    const tableSettings: string | undefined = adaptTableSettingsForStorage(
+      this.model.tableSettings,
+    );
+    if (tableSettings) {
+      statement.append(`\nSETTINGS ${tableSettings}`);
     }
 
     /* eslint-enable prettier/prettier */
@@ -1439,4 +1489,34 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
 
     return statement;
   }
+
+  /*
+   * The app-facing Distributed table that wraps the model's local storage table.
+   * Built with `AS <db>.<local>` so its column layout is copied from — and stays
+   * identical to — the local table, and with `CREATE OR REPLACE` so re-running it
+   * every boot atomically re-syncs the wrapper after a column is reconciled onto
+   * the local table (the Distributed table holds no data, so the replace is cheap
+   * and lossless). The Distributed engine routes writes by the model's sharding
+   * key and scatter-gathers reads across all shards.
+   */
+  public toDistributedTableCreateStatement(): Statement {
+    const databaseName: string = this.database.getDatasourceOptions().database!;
+    const distributedTableName: string = this.model.tableName;
+    const localTableName: string = getStorageTableName(this.model.tableName);
+    const onCluster: string = onClusterClause();
+    const distributedEngine: string = getDistributedEngine(
+      localTableName,
+      this.model.shardingKey,
+    );
+
+    const statement: Statement = new Statement();
+    statement.append(
+      `CREATE OR REPLACE TABLE ${databaseName}.${distributedTableName}${onCluster} AS ${databaseName}.${localTableName} ENGINE = ${distributedEngine}`,
+    );
+
+    logger.debug(`${this.model.tableName} Distributed Table Create Statement`);
+    logger.debug(statement);
+
+    return statement;
+  }
 }

package/Server/Utils/CodeRepository/CodeRepository.ts

@@ -397,6 +397,13 @@ export default class CodeRepositoryUtil {
   public static async getCommitAuthorsWithFiles(data: {
     repoPath: string;
     path?: string | undefined;
+    /*
+     * Hard upper bound (ms) on the `git log` invocation. Over a full-history repo
+     * this walk can take a very long time, so callers on (or near) a request path
+     * should bound it; on timeout the child is killed and this rejects, letting
+     * the caller fall back gracefully.
+     */
+    timeoutInMS?: number | undefined;
   }): Promise<
     Array<{
       authorName: string;
@@ -428,6 +435,7 @@ export default class CodeRepositoryUtil {
       cwd: path.resolve(data.repoPath),
       // git log over a full repo can easily exceed the 1 MB default.
       maxBuffer: 256 * 1024 * 1024,
+      ...(data.timeoutInMS ? { timeoutInMS: data.timeoutInMS } : {}),
     });
 
     const commits: Array<{

package/Server/Utils/Execute.ts

@@ -59,6 +59,12 @@ export default class Execute {
      * can emit large output (e.g. `git log` over a whole repo) should raise this.
      */
     maxBuffer?: number | undefined;
+    /*
+     * Hard upper bound (ms) on how long the child may run. When exceeded the
+     * child is force-killed (SIGKILL) and the promise rejects, so a slow command
+     * (e.g. `git log` over a huge full-history repo) can never hang the caller.
+     */
+    timeoutInMS?: number | undefined;
   }): Promise<string> {
     return new Promise(
       (
@@ -71,6 +77,9 @@ export default class Execute {
           {
             cwd: data.cwd,
             ...(data.maxBuffer ? { maxBuffer: data.maxBuffer } : {}),
+            ...(data.timeoutInMS
+              ? { timeout: data.timeoutInMS, killSignal: "SIGKILL" }
+              : {}),
           },
           (err: ExecException | null, stdout: string, stderr: string) => {
             if (err) {

package/Server/Utils/Monitor/MonitorTemplateUtil.ts

@@ -399,6 +399,9 @@ export default class MonitorTemplateUtil {
           failureCause: externalStatusPageResponse?.failureCause,
           overallStatus: externalStatusPageResponse?.overallStatus,
           activeIncidentCount: externalStatusPageResponse?.activeIncidentCount,
+          provider: externalStatusPageResponse?.provider,
+          componentGroup: externalStatusPageResponse?.componentGroupName,
+          componentName: externalStatusPageResponse?.componentName,
         } as JSONObject;
 
         // Add component statuses
@@ -410,6 +413,7 @@ export default class MonitorTemplateUtil {
                   name: component.name,
                   status: component.status,
                   description: component.description,
+                  groupName: component.groupName,
                 };
               },
             );

package/Tests/Server/Services/AnalyticsDatabaseService.test.ts

@@ -356,13 +356,18 @@ describe("AnalyticsDatabaseService", () => {
         tableName: "<table-name>",
       });
 
+      /*
+       * Cluster mode: deletes are an ALTER ... DELETE mutation on the local
+       * table, dispatched ON CLUSTER (lightweight DELETE can't hit a Distributed
+       * table).
+       */
       expect(statement.query).toBe(
-        "DELETE FROM {p0:Identifier}.{p1:Identifier}\n" +
-          "WHERE TRUE <where-statement>",
+        "ALTER TABLE {p0:Identifier}.{p1:Identifier} ON CLUSTER 'oneuptime'\n" +
+          "DELETE WHERE TRUE <where-statement>",
       );
       expect(statement.query_params).toStrictEqual({
         p0: "oneuptime",
-        p1: "<table-name>",
+        p1: "<table-name>Local",
       });
     });
   });

package/Tests/Server/Utils/AnalyticsDatabase/ClusterAwareSchema.test.ts

@@ -0,0 +1,296 @@
+import { ClickhouseAppInstance } from "../../../../Server/Infrastructure/ClickhouseDatabase";
+import StatementGenerator from "../../../../Server/Utils/AnalyticsDatabase/StatementGenerator";
+import {
+  SQL,
+  Statement,
+} from "../../../../Server/Utils/AnalyticsDatabase/Statement";
+import {
+  adaptTableSettingsForStorage,
+  applyClusterToMaterializedViewQuery,
+  getClickhouseClusterName,
+  getDistributedEngine,
+  getStorageEngine,
+  getStorageTableName,
+  onClusterClause,
+} from "../../../../Server/Utils/AnalyticsDatabase/ClusterConfig";
+import UpdateBy from "../../../../Server/Types/AnalyticsDatabase/UpdateBy";
+import "../../TestingUtils/Init";
+import AnalyticsBaseModel from "../../../../Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
+import Route from "../../../../Types/API/Route";
+import AnalyticsTableEngine from "../../../../Types/AnalyticsDatabase/AnalyticsTableEngine";
+import AnalyticsTableColumn, {
+  SkipIndexType,
+} from "../../../../Types/AnalyticsDatabase/TableColumn";
+import TableColumnType from "../../../../Types/AnalyticsDatabase/TableColumnType";
+
+const CLUSTER_ENV_KEY: string = "CLICKHOUSE_CLUSTER_NAME";
+const SHARDING_ENV_KEY: string = "CLICKHOUSE_SHARDING_KEY";
+
+/*
+ * Flatten a Statement into a single string (raw SQL + serialized identifier
+ * params) so assertions don't have to care whether a name landed in the query
+ * text or in query_params as a {pN:Identifier} parameter.
+ */
+function fullText(statement: Statement | string): string {
+  if (typeof statement === "string") {
+    return statement;
+  }
+  return statement.query + " :: " + JSON.stringify(statement.query_params);
+}
+
+describe("ClickHouse cluster-aware schema (always-on)", () => {
+  const originalCluster: string | undefined = process.env[CLUSTER_ENV_KEY];
+  const originalSharding: string | undefined = process.env[SHARDING_ENV_KEY];
+
+  afterEach(() => {
+    if (originalCluster === undefined) {
+      delete process.env[CLUSTER_ENV_KEY];
+    } else {
+      process.env[CLUSTER_ENV_KEY] = originalCluster;
+    }
+    if (originalSharding === undefined) {
+      delete process.env[SHARDING_ENV_KEY];
+    } else {
+      process.env[SHARDING_ENV_KEY] = originalSharding;
+    }
+  });
+
+  describe("ClusterConfig helpers", () => {
+    test("cluster name defaults to 'oneuptime' and is overridable", () => {
+      delete process.env[CLUSTER_ENV_KEY];
+      expect(getClickhouseClusterName()).toBe("oneuptime");
+      expect(onClusterClause()).toBe(" ON CLUSTER 'oneuptime'");
+
+      process.env[CLUSTER_ENV_KEY] = "ext_cluster";
+      expect(getClickhouseClusterName()).toBe("ext_cluster");
+      expect(onClusterClause()).toBe(" ON CLUSTER 'ext_cluster'");
+
+      // whitespace-only falls back to the default
+      process.env[CLUSTER_ENV_KEY] = "   ";
+      expect(getClickhouseClusterName()).toBe("oneuptime");
+    });
+
+    test("storage table name always gets the Local suffix", () => {
+      expect(getStorageTableName("SpanItemV3")).toBe("SpanItemV3Local");
+    });
+
+    test("engines always map to their Replicated variant", () => {
+      expect(getStorageEngine(AnalyticsTableEngine.MergeTree)).toBe(
+        "ReplicatedMergeTree",
+      );
+      expect(getStorageEngine(AnalyticsTableEngine.AggregatingMergeTree)).toBe(
+        "ReplicatedAggregatingMergeTree",
+      );
+    });
+
+    test("table settings always swap to the replicated dedup window", () => {
+      expect(
+        adaptTableSettingsForStorage(
+          "ttl_only_drop_parts = 1, non_replicated_deduplication_window = 10000",
+        ),
+      ).toBe(
+        "ttl_only_drop_parts = 1, replicated_deduplication_window = 10000",
+      );
+    });
+
+    test("distributed engine: model key, with global override winning", () => {
+      delete process.env[SHARDING_ENV_KEY];
+      // model sharding key is used
+      expect(
+        getDistributedEngine("SpanItemV3Local", "cityHash64(traceId)"),
+      ).toContain("SpanItemV3Local, cityHash64(traceId))");
+      // no model key -> default cityHash64(projectId)
+      expect(getDistributedEngine("LogItemV3Local")).toContain(
+        "cityHash64(projectId))",
+      );
+      // global override wins over the model key
+      process.env[SHARDING_ENV_KEY] = "rand()";
+      expect(
+        getDistributedEngine("SpanItemV3Local", "cityHash64(traceId)"),
+      ).toContain("SpanItemV3Local, rand())");
+    });
+  });
+
+  describe("StatementGenerator DDL", () => {
+    class SpanModel extends AnalyticsBaseModel {
+      public constructor() {
+        super({
+          tableName: "SpanItemV3",
+          singularName: "Span",
+          pluralName: "Spans",
+          tableColumns: [
+            new AnalyticsTableColumn({
+              key: "projectId",
+              title: "Project",
+              description: "Project",
+              required: true,
+              type: TableColumnType.ObjectID,
+            }),
+            new AnalyticsTableColumn({
+              key: "traceId",
+              title: "Trace",
+              description: "Trace",
+              required: true,
+              type: TableColumnType.Text,
+              skipIndex: {
+                name: "idx_trace_id",
+                type: SkipIndexType.BloomFilter,
+                params: [0.01],
+                granularity: 1,
+              },
+            }),
+          ],
+          crudApiPath: new Route("span"),
+          primaryKeys: ["projectId"],
+          sortKeys: ["projectId"],
+          partitionKey: "toYYYYMMDD(startTime)",
+          shardingKey: "cityHash64(traceId)",
+          tableEngine: AnalyticsTableEngine.MergeTree,
+          ttlExpression: "retentionDate DELETE",
+          tableSettings:
+            "ttl_only_drop_parts = 1, non_replicated_deduplication_window = 10000",
+        });
+      }
+    }
+
+    class AggregatingModel extends AnalyticsBaseModel {
+      public constructor() {
+        super({
+          tableName: "MetricItemAggMV1m",
+          singularName: "Agg",
+          pluralName: "Aggs",
+          tableColumns: [
+            new AnalyticsTableColumn({
+              key: "projectId",
+              title: "Project",
+              description: "Project",
+              required: true,
+              type: TableColumnType.ObjectID,
+            }),
+          ],
+          crudApiPath: new Route("agg"),
+          primaryKeys: ["projectId"],
+          sortKeys: ["projectId"],
+          partitionKey: "toYYYYMM(bucketTime)",
+          tableEngine: AnalyticsTableEngine.AggregatingMergeTree,
+        });
+      }
+    }
+
+    let spanGen: StatementGenerator<SpanModel>;
+    let aggregatingGen: StatementGenerator<AggregatingModel>;
+
+    beforeEach(() => {
+      delete process.env[CLUSTER_ENV_KEY];
+      delete process.env[SHARDING_ENV_KEY];
+      spanGen = new StatementGenerator<SpanModel>({
+        modelType: SpanModel,
+        database: ClickhouseAppInstance,
+      });
+      aggregatingGen = new StatementGenerator<AggregatingModel>({
+        modelType: AggregatingModel,
+        database: ClickhouseAppInstance,
+      });
+    });
+
+    test("CREATE TABLE builds the local Replicated table ON CLUSTER with replicated dedup", () => {
+      const stmt: Statement = spanGen.toTableCreateStatement();
+      expect(stmt.query).toContain("ENGINE = ReplicatedMergeTree");
+      expect(stmt.query).toContain("ON CLUSTER 'oneuptime'");
+      expect(stmt.query).toContain("replicated_deduplication_window = 10000");
+      expect(stmt.query).not.toContain("non_replicated_deduplication_window");
+      expect(fullText(stmt)).toContain("SpanItemV3Local");
+    });
+
+    test("cluster name override flows into the DDL", () => {
+      process.env[CLUSTER_ENV_KEY] = "ext_cluster";
+      expect(spanGen.toTableCreateStatement().query).toContain(
+        "ON CLUSTER 'ext_cluster'",
+      );
+    });
+
+    test("AggregatingMergeTree maps to ReplicatedAggregatingMergeTree", () => {
+      const stmt: Statement = aggregatingGen.toTableCreateStatement();
+      expect(stmt.query).toContain("ENGINE = ReplicatedAggregatingMergeTree");
+      expect(fullText(stmt)).toContain("MetricItemAggMV1mLocal");
+    });
+
+    test("Distributed wrapper uses the model sharding key and local table", () => {
+      const q: string = spanGen.toDistributedTableCreateStatement().query;
+      expect(q).toContain("ON CLUSTER 'oneuptime'");
+      expect(q).toContain(
+        "Distributed('oneuptime', oneuptime, SpanItemV3Local, cityHash64(traceId))",
+      );
+      expect(q).toContain("AS ");
+      expect(q).toContain("SpanItemV3 "); // the app-facing distributed name
+    });
+
+    test("global sharding-key override beats the model key in the Distributed engine", () => {
+      process.env[SHARDING_ENV_KEY] = "rand()";
+      expect(spanGen.toDistributedTableCreateStatement().query).toContain(
+        "SpanItemV3Local, rand())",
+      );
+    });
+
+    test("schema ALTERs target the local table", () => {
+      const column: AnalyticsTableColumn = new SpanModel().tableColumns[1]!;
+      expect(fullText(spanGen.toAddColumnStatement(column))).toContain(
+        "SpanItemV3Local",
+      );
+      expect(fullText(spanGen.toAddSkipIndexStatement(column)!)).toContain(
+        "SpanItemV3Local",
+      );
+      expect(spanGen.toDropColumnStatement("traceId")).toContain(
+        "SpanItemV3Local",
+      );
+      expect(spanGen.toDropSkipIndexStatement("idx_trace_id")).toContain(
+        "SpanItemV3Local",
+      );
+    });
+
+    test("ALTER UPDATE mutates the local table with ON CLUSTER", () => {
+      spanGen.toSetStatement = jest.fn(() => {
+        return SQL`name = 'x'`;
+      });
+      spanGen.toWhereStatement = jest.fn(() => {
+        return SQL` AND projectId = 'p'`;
+      });
+      const updateBy: UpdateBy<SpanModel> = {
+        data: new SpanModel(),
+        query: {},
+        props: {},
+      };
+      const stmt: Statement = spanGen.toUpdateStatement(updateBy);
+      expect(stmt.query).toContain("ON CLUSTER 'oneuptime'");
+      expect(stmt.query).toContain("UPDATE");
+      expect(fullText(stmt)).toContain("SpanItemV3Local");
+    });
+  });
+
+  describe("applyClusterToMaterializedViewQuery", () => {
+    const MV_QUERY: string = `CREATE MATERIALIZED VIEW IF NOT EXISTS MetricItemAggMV1m_mv
+TO MetricItemAggMV1m
+AS
+SELECT
+  projectId,
+  toStartOfMinute(time) AS bucketTime,
+  sumState(toFloat64(coalesce(value, sum, 0))) AS valueSumState
+FROM MetricItemV3
+GROUP BY projectId, bucketTime`;
+
+    test("injects ON CLUSTER and retargets TO/FROM at local tables", () => {
+      delete process.env[CLUSTER_ENV_KEY];
+      const out: string = applyClusterToMaterializedViewQuery(MV_QUERY);
+      expect(out).toContain(
+        "CREATE MATERIALIZED VIEW IF NOT EXISTS MetricItemAggMV1m_mv ON CLUSTER 'oneuptime'",
+      );
+      expect(out).toContain("TO MetricItemAggMV1mLocal");
+      expect(out).toContain("FROM MetricItemV3Local");
+      // aggregate columns / time bucketing must NOT be rewritten
+      expect(out).toContain("toStartOfMinute(time) AS bucketTime");
+      expect(out).toContain("sumState(toFloat64(coalesce(value, sum, 0)))");
+      expect(out).not.toContain("MetricItemAggMV1mLocalLocal");
+      expect(out).not.toContain("MetricItemV3LocalLocal");
+    });
+  });
+});

package/Tests/Server/Utils/AnalyticsDatabase/StatementGenerator.test.ts

@@ -111,10 +111,11 @@ describe("StatementGenerator", () => {
       expect(jest.mocked(logger.debug)).toHaveBeenNthCalledWith(2, statement);
 
       /* eslint-disable prettier/prettier */
+      // Cluster mode: mutation targets the local table and dispatches ON CLUSTER.
       expectStatement(
         statement,
         SQL`
-                ALTER TABLE ${"oneuptime"}.${"<table-name>"}
+                ALTER TABLE ${"oneuptime"}.${"<table-name>Local"} ON CLUSTER 'oneuptime'
                 UPDATE <set-statement>
                 WHERE TRUE <where-statement>
             `,
@@ -868,12 +869,13 @@ describe("StatementGenerator", () => {
       expect(jest.mocked(logger.debug)).toHaveBeenNthCalledWith(2, statement);
 
       /* eslint-disable prettier/prettier */
+      // Cluster mode: the local <table>Local table, Replicated engine, ON CLUSTER.
       const expectedStatement: Statement = SQL`
-            CREATE TABLE IF NOT EXISTS ${"oneuptime"}.${"<table-name>"}
+            CREATE TABLE IF NOT EXISTS ${"oneuptime"}.${"<table-name>Local"} ON CLUSTER 'oneuptime'
     (
         <columns-create-statement>
     )
-    ENGINE = MergeTree
+    ENGINE = ReplicatedMergeTree
 PARTITION BY (column_ObjectID)
 
     PRIMARY KEY (${"column_ObjectID"})

package/Types/Monitor/ExternalStatusPageMonitor/ExternalStatusPageMonitorResponse.ts

@@ -4,6 +4,7 @@ export interface ExternalStatusPageComponentStatus {
   name: string;
   status: string;
   description?: string | undefined;
+  groupName?: string | undefined; // the component group this component belongs to, if any
 }
 
 export default interface ExternalStatusPageMonitorResponse {
@@ -13,6 +14,10 @@ export default interface ExternalStatusPageMonitorResponse {
   activeIncidentCount: number;
   responseTimeInMs: number;
   failureCause: string;
+  // Echoes of the resolved query scope, so consumers (summary view, templates) can show what was queried.
+  provider?: string | undefined;
+  componentGroupName?: string | undefined;
+  componentName?: string | undefined;
   rawBody?: string | undefined;
   isTimeout?: boolean | undefined;
   probeAttempts?: Array<ProbeAttempt> | undefined;

package/Types/Monitor/ExternalStatusPageProviderType.ts

@@ -1,5 +1,6 @@
 enum ExternalStatusPageProviderType {
   AtlassianStatuspage = "Atlassian Statuspage",
+  IncidentIo = "incident.io",
   RSS = "RSS",
   Atom = "Atom",
   Auto = "Auto",