@oneuptime/common 10.0.96 → 10.0.97

package/Server/Services/MetricService.ts

@@ -57,6 +57,20 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
     columns: Array<string>;
   } {
     if (!isPercentileAggregation(aggregateBy.aggregationType)) {
+      /*
+       * Try the per-host MV first — host detail pages are the
+       * dominant attribute-filtered path and the per-host MV is
+       * the only one that can serve them. If it doesn't apply
+       * (no host filter, or extra attrs/groupBy), fall through
+       * to the project/serviceId MV, then to the base table.
+       */
+      const hostMvStatement: {
+        statement: Statement;
+        columns: Array<string>;
+      } | null = this.tryBuildHostAggregateMVStatement(aggregateBy);
+      if (hostMvStatement) {
+        return hostMvStatement;
+      }
       const mvStatement: {
         statement: Statement;
         columns: Array<string>;
@@ -401,6 +415,192 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
     };
   }
 
+  /*
+   * Per-host materialized-view fast path.
+   *
+   * Returns a statement that reads from MetricItemAggMV1mByHost
+   * (created by AddMetricMinuteAggregateByHostMaterializedView)
+   * when:
+   *
+   *   - The aggregation is Sum/Avg/Min/Max/Count over `value`.
+   *   - The only attribute filter is `resource.host.name` as a
+   *     bare-string equality (the dashboard's host detail page
+   *     pattern).
+   *   - The query carries no group-by other than the time
+   *     bucket — the MV is keyed by hostIdentifier and does not
+   *     preserve other attribute breakdowns.
+   *
+   * Returns `null` if any condition fails so the caller falls
+   * through to the next fast path / base table. The result row
+   * shape (columns: aggregateColumn, timestampColumn) matches
+   * the base statement so downstream code needs no changes.
+   */
+  private tryBuildHostAggregateMVStatement(
+    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;
+    }
+
+    if (aggregateBy.groupBy && Object.keys(aggregateBy.groupBy).length > 0) {
+      return null;
+    }
+
+    /*
+     * Inspect the attribute filter. This MV is only safe when
+     * the user is filtering by exactly one attribute,
+     * `resource.host.name`, with a bare-string value (the
+     * canonical Overview/Metrics-page pattern). Anything else —
+     * extra attribute filters, NotEqual, Search, etc. — has to
+     * fall back so the result stays correct.
+     */
+    const queryRecord: Record<string, unknown> =
+      (aggregateBy.query as unknown as Record<string, unknown>) || {};
+    const attrs: unknown = queryRecord["attributes"];
+    if (!attrs || typeof attrs !== "object") {
+      return null;
+    }
+    const attrEntries: Array<[string, unknown]> = Object.entries(
+      attrs as Record<string, unknown>,
+    );
+    if (attrEntries.length !== 1) {
+      return null;
+    }
+    const [attrKey, attrValue] = attrEntries[0]!;
+    if (attrKey !== "resource.host.name") {
+      return null;
+    }
+    if (attrValue === undefined || attrValue === null) {
+      return null;
+    }
+    const hostIdentifier: string =
+      typeof attrValue === "string" ? attrValue : "";
+    if (!hostIdentifier) {
+      return null;
+    }
+
+    const interval: AggregationInterval = AggregateUtil.getAggregationInterval({
+      startDate: aggregateBy.startTimestamp!,
+      endDate: aggregateBy.endTimestamp!,
+    });
+    void interval;
+
+    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 {
+      mergedExpr = `if(countMerge(valueCountState) = 0, 0, sumMerge(valueSumState) / countMerge(valueCountState))`;
+    }
+
+    /*
+     * Strip both `time` (column doesn't exist on the MV; we
+     * inject an explicit bucketTime range below) and
+     * `attributes` (the attribute filter is now an explicit
+     * `hostIdentifier =` predicate against an MV column).
+     */
+    const filteredQuery: typeof aggregateBy.query =
+      this.stripAttributesAndTimeFromQuery(
+        aggregateBy.query,
+      ) as typeof aggregateBy.query;
+    const nonTimeWhere: Statement =
+      this.statementGenerator.toWhereStatement(filteredQuery);
+    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}.MetricItemAggMV1mByHost`);
+    statement.append(
+      ` WHERE bucketTime >= toDateTime('${this.formatDateTime(aggregateBy.startTimestamp!)}') AND bucketTime <= toDateTime('${this.formatDateTime(aggregateBy.endTimestamp!)}')`,
+    );
+    statement.append(
+      SQL` AND hostIdentifier = ${{
+        value: hostIdentifier,
+        type: TableColumnType.Text,
+      }}`,
+    );
+    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} Host 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 stripAttributesAndTimeFromQuery(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" || k === "attributes") {
+        continue;
+      }
+      out[k] = v;
+    }
+    return out as typeof query;
+  }
+
   private stripTimeFromQuery(query: unknown): typeof query {
     if (!query || typeof query !== "object") {
       return query;

package/Server/Services/TraceAggregationService.ts

@@ -503,14 +503,19 @@ export class TraceAggregationService {
       for (const [attrKey, attrValue] of Object.entries(request.attributes)) {
         TraceAggregationService.validateFacetKey(attrKey);
 
+        /*
+         * Match attribute keys case-insensitively — see the matching note in
+         * LogAggregationService.appendCommonFilters. Casings vary across
+         * OTEL conventions and app-emitted attributes.
+         */
         statement.append(
-          SQL` AND attributes[${{
+          SQL` AND arrayExists((k, v) -> lowerUTF8(k) = lowerUTF8(${{
             type: TableColumnType.Text,
             value: attrKey,
-          }}] = ${{
+          }}) AND v = ${{
             type: TableColumnType.Text,
             value: attrValue,
-          }}`,
+          }}, mapKeys(attributes), mapValues(attributes))`,
         );
       }
     }

package/Server/Utils/AnalyticsDatabase/StatementGenerator.ts

@@ -463,10 +463,35 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
           }
 
           /*
-           * ClickHouse Map columns return the value type's default for
-           * missing keys (empty string for String values), so to express
-           * "is empty" we have to cover both the missing-key and the
-           * empty-string case explicitly.
+           * Map filters split into two paths:
+           *
+           * 1. Programmatic equality / null / numeric comparisons —
+           *    EqualTo, NotEqual, IsNull, NotNull, GreaterThan, etc.,
+           *    or bare string/number values. Callers are dashboard
+           *    pages and services that pass canonical keys already
+           *    matching the stored casing, so we use ClickHouse's
+           *    direct Map subscript `attributes['k']`. That's an O(1)
+           *    hash lookup per row and lets the query planner push the
+           *    predicate into PREWHERE, instead of paying the
+           *    `arrayExists((k, v) -> lowerUTF8(k) = lowerUTF8(...))`
+           *    cost which materializes mapKeys/mapValues per row and
+           *    lowercases every stored key on every query. Restoring
+           *    this fast path is the single biggest performance fix
+           *    for Host / Logs / Traces detail pages.
+           *
+           * 2. User-typed substring/wildcard operators — Search,
+           *    StartsWith, EndsWith, NotContains. These come from the
+           *    search bar where users shouldn't have to remember
+           *    whether the attribute key is `requestId` or `requestid`,
+           *    so we keep the case-insensitive `arrayExists` form. The
+           *    cost is acceptable because a search-bar query is
+           *    bounded (one user, one click) and these operators
+           *    already imply a row scan.
+           *
+           * ClickHouse Map subscripts return the value type's default
+           * for missing keys (empty string for String values), which
+           * is what the IsNull / NotNull / NotEqual branches below
+           * mirror to preserve the previous semantics.
            */
           if (mapEntry instanceof IsNull) {
             whereStatement.append(
@@ -496,13 +521,13 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
 
           if (mapEntry instanceof Search) {
             whereStatement.append(
-              SQL`AND ${key}[${{
+              SQL`AND arrayExists((k, v) -> lowerUTF8(k) = lowerUTF8(${{
                 value: mapKey,
                 type: TableColumnType.Text,
-              }}] ILIKE ${{
+              }}) AND v ILIKE ${{
                 value: mapEntry as Search<string>,
                 type: TableColumnType.Text,
-              }}`,
+              }}, mapKeys(${key}), mapValues(${key}))`,
             );
             continue;
           }
@@ -510,13 +535,13 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
           if (mapEntry instanceof NotContains) {
             const literalValue: string = `%${(mapEntry.value as string) || ""}%`;
             whereStatement.append(
-              SQL`AND ${key}[${{
+              SQL`AND NOT arrayExists((k, v) -> lowerUTF8(k) = lowerUTF8(${{
                 value: mapKey,
                 type: TableColumnType.Text,
-              }}] NOT ILIKE ${{
+              }}) AND v ILIKE ${{
                 value: literalValue,
                 type: TableColumnType.Text,
-              }}`,
+              }}, mapKeys(${key}), mapValues(${key}))`,
             );
             continue;
           }
@@ -524,13 +549,13 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
           if (mapEntry instanceof StartsWith) {
             const literalValue: string = `${(mapEntry.value as string) || ""}%`;
             whereStatement.append(
-              SQL`AND ${key}[${{
+              SQL`AND arrayExists((k, v) -> lowerUTF8(k) = lowerUTF8(${{
                 value: mapKey,
                 type: TableColumnType.Text,
-              }}] ILIKE ${{
+              }}) AND v ILIKE ${{
                 value: literalValue,
                 type: TableColumnType.Text,
-              }}`,
+              }}, mapKeys(${key}), mapValues(${key}))`,
             );
             continue;
           }
@@ -538,13 +563,13 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
           if (mapEntry instanceof EndsWith) {
             const literalValue: string = `%${(mapEntry.value as string) || ""}`;
             whereStatement.append(
-              SQL`AND ${key}[${{
+              SQL`AND arrayExists((k, v) -> lowerUTF8(k) = lowerUTF8(${{
                 value: mapKey,
                 type: TableColumnType.Text,
-              }}] ILIKE ${{
+              }}) AND v ILIKE ${{
                 value: literalValue,
                 type: TableColumnType.Text,
-              }}`,
+              }}, mapKeys(${key}), mapValues(${key}))`,
             );
             continue;
           }
@@ -577,7 +602,10 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
 
           /*
            * Map values are stored as text; cast to Float64 for numeric
-           * comparisons and skip rows where the cast fails (non-numeric).
+           * comparisons. toFloat64OrNull yields NULL for non-numeric
+           * values (including the empty-string default for missing
+           * keys), which compares to false against any numeric
+           * threshold and naturally drops those rows.
            */
           if (mapEntry instanceof GreaterThan) {
             whereStatement.append(
@@ -631,7 +659,7 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
             continue;
           }
 
-          // Bare string/number/boolean — back-compat with existing data.
+          // Bare string/number/boolean — direct Map subscript.
           whereStatement.append(
             SQL`AND ${key}[${{
               value: mapKey,

package/Server/Utils/Monitor/MonitorAlert.ts

@@ -1,6 +1,7 @@
 import Alert from "../../../Models/DatabaseModels/Alert";
 import AlertSeverity from "../../../Models/DatabaseModels/AlertSeverity";
 import AlertStateTimeline from "../../../Models/DatabaseModels/AlertStateTimeline";
+import Host from "../../../Models/DatabaseModels/Host";
 import Label from "../../../Models/DatabaseModels/Label";
 import Monitor from "../../../Models/DatabaseModels/Monitor";
 import OnCallDutyPolicy from "../../../Models/DatabaseModels/OnCallDutyPolicy";
@@ -17,6 +18,7 @@ import { DisableAutomaticAlertCreation } from "../../EnvironmentConfig";
 import AlertService from "../../Services/AlertService";
 import AlertSeverityService from "../../Services/AlertSeverityService";
 import AlertStateTimelineService from "../../Services/AlertStateTimelineService";
+import HostService from "../../Services/HostService";
 import logger, { LogAttributes } from "../Logger";
 import CaptureSpan from "../Telemetry/CaptureSpan";
 import DataToProcess from "./DataToProcess";
@@ -268,6 +270,35 @@ export default class MonitorAlert {
         }
         if (seriesLabels && Object.keys(seriesLabels).length > 0) {
           alert.seriesLabels = seriesLabels;
+
+          /*
+           * Link the alert to the Host that emitted this series, if
+           * the metric carried a `host.name` resource attribute. The
+           * Host record was auto-discovered during OTel ingestion.
+           */
+          const hostName: string | undefined =
+            typeof seriesLabels["host.name"] === "string"
+              ? (seriesLabels["host.name"] as string)
+              : undefined;
+
+          if (hostName) {
+            const host: Host | null = await HostService.findOneBy({
+              query: {
+                projectId: input.monitor.projectId!,
+                hostIdentifier: hostName,
+              },
+              select: {
+                _id: true,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+            if (host) {
+              alert.hosts = [host];
+            }
+          }
         }
 
         alert.onCallDutyPolicies =

package/Server/Utils/Monitor/MonitorIncident.ts

@@ -1,3 +1,4 @@
+import Host from "../../../Models/DatabaseModels/Host";
 import Incident from "../../../Models/DatabaseModels/Incident";
 import IncidentSeverity from "../../../Models/DatabaseModels/IncidentSeverity";
 import IncidentStateTimeline from "../../../Models/DatabaseModels/IncidentStateTimeline";
@@ -15,6 +16,7 @@ import ObjectID from "../../../Types/ObjectID";
 import ProbeMonitorResponse from "../../../Types/Probe/ProbeMonitorResponse";
 import { TelemetryQuery } from "../../../Types/Telemetry/TelemetryQuery";
 import { DisableAutomaticIncidentCreation } from "../../EnvironmentConfig";
+import HostService from "../../Services/HostService";
 import IncidentService from "../../Services/IncidentService";
 import IncidentSeverityService from "../../Services/IncidentSeverityService";
 import IncidentStateTimelineService from "../../Services/IncidentStateTimelineService";
@@ -313,6 +315,35 @@ export default class MonitorIncident {
         }
         if (seriesLabels && Object.keys(seriesLabels).length > 0) {
           incident.seriesLabels = seriesLabels;
+
+          /*
+           * Link the incident to the Host that emitted this series, if
+           * the metric carried a `host.name` resource attribute. The
+           * Host record was auto-discovered during OTel ingestion.
+           */
+          const hostName: string | undefined =
+            typeof seriesLabels["host.name"] === "string"
+              ? (seriesLabels["host.name"] as string)
+              : undefined;
+
+          if (hostName) {
+            const host: Host | null = await HostService.findOneBy({
+              query: {
+                projectId: input.monitor.projectId!,
+                hostIdentifier: hostName,
+              },
+              select: {
+                _id: true,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+            if (host) {
+              incident.hosts = [host];
+            }
+          }
         }
 
         incident.onCallDutyPolicies =

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

@@ -80,4 +80,29 @@ describe("LogAggregationService", () => {
       });
     }).toThrow("Invalid facetKey");
   });
+
+  test("histogram attribute filter matches attribute keys case-insensitively", () => {
+    /*
+     * Users typing `requestid` should still match data stored with the key
+     * `requestId` (camelCase). The histogram filter shares the same WHERE
+     * clause builder (`appendCommonFilters`) with the list/facet queries, so
+     * verifying it on histogram covers all three.
+     */
+    const statement: Statement = (
+      LogAggregationService as any
+    ).buildHistogramStatement({
+      ...defaultRequest,
+      facetKey: undefined,
+      attributes: { requestid: "uuid-123" },
+    });
+
+    expect(statement.query).toContain(
+      "arrayExists((k, v) -> lowerUTF8(k) = lowerUTF8(",
+    );
+    expect(statement.query).toContain(
+      ", mapKeys(attributes), mapValues(attributes))",
+    );
+    expect(Object.values(statement.query_params)).toContain("requestid");
+    expect(Object.values(statement.query_params)).toContain("uuid-123");
+  });
 });

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

@@ -13,6 +13,13 @@ import AnalyticsTableEngine from "../../../../Types/AnalyticsDatabase/AnalyticsT
 import AnalyticsTableColumn from "../../../../Types/AnalyticsDatabase/TableColumn";
 import TableColumnType from "../../../../Types/AnalyticsDatabase/TableColumnType";
 import OneUptimeDate from "../../../../Types/Date";
+import EqualTo from "../../../../Types/BaseDatabase/EqualTo";
+import NotEqual from "../../../../Types/BaseDatabase/NotEqual";
+import IsNull from "../../../../Types/BaseDatabase/IsNull";
+import NotNull from "../../../../Types/BaseDatabase/NotNull";
+import GreaterThan from "../../../../Types/BaseDatabase/GreaterThan";
+import Search from "../../../../Types/BaseDatabase/Search";
+import StartsWith from "../../../../Types/BaseDatabase/StartsWith";
 
 function expectStatement(actual: Statement, expected: Statement): void {
   expect(actual.query).toBe(expected.query);
@@ -179,6 +186,144 @@ describe("StatementGenerator", () => {
         p3: OneUptimeDate.toClickhouseDateTime(date),
       });
     });
+
+    describe("MapStringString columns", () => {
+      class MapModel extends AnalyticsBaseModel {
+        public constructor() {
+          super({
+            tableName: "<map-table>",
+            singularName: "<singular>",
+            pluralName: "<plural>",
+            tableColumns: [
+              new AnalyticsTableColumn({
+                key: "_id",
+                title: "<title>",
+                description: "<description>",
+                required: true,
+                type: TableColumnType.ObjectID,
+              }),
+              new AnalyticsTableColumn({
+                key: "attributes",
+                title: "<title>",
+                description: "<description>",
+                required: true,
+                defaultValue: {},
+                type: TableColumnType.MapStringString,
+              }),
+            ],
+            crudApiPath: new Route("route"),
+            primaryKeys: ["_id"],
+            sortKeys: ["_id"],
+            partitionKey: "_id",
+            tableEngine: AnalyticsTableEngine.MergeTree,
+          });
+        }
+      }
+
+      let mapGenerator: StatementGenerator<MapModel>;
+      beforeEach(() => {
+        mapGenerator = new StatementGenerator<MapModel>({
+          modelType: MapModel,
+          database: ClickhouseAppInstance,
+        });
+      });
+
+      test("uses direct map subscript for bare-value equality", () => {
+        const statement: Statement = mapGenerator.toWhereStatement({
+          attributes: { requestId: "uuid-123" },
+        } as any);
+        /*
+         * Programmatic callers pass canonical keys, so bare-value
+         * equality compiles to `attributes['k'] = v` — an O(1) Map
+         * subscript that the planner can push into PREWHERE. The
+         * slower case-insensitive arrayExists form is reserved for
+         * the user-typed Search/StartsWith/EndsWith/NotContains
+         * operators below.
+         */
+        expect(statement.query).toBe(
+          "AND {p0:Identifier}[{p1:String}] = {p2:String}",
+        );
+        expect(statement.query_params).toStrictEqual({
+          p0: "attributes",
+          p1: "requestId",
+          p2: "uuid-123",
+        });
+      });
+
+      test("uses direct map subscript for EqualTo wrapper", () => {
+        const statement: Statement = mapGenerator.toWhereStatement({
+          attributes: { requestId: new EqualTo("uuid-123") },
+        } as any);
+        expect(statement.query).toBe(
+          "AND {p0:Identifier}[{p1:String}] = {p2:String}",
+        );
+        expect(statement.query_params).toStrictEqual({
+          p0: "attributes",
+          p1: "requestId",
+          p2: "uuid-123",
+        });
+      });
+
+      test("uses direct map subscript for NotEqual wrapper", () => {
+        const statement: Statement = mapGenerator.toWhereStatement({
+          attributes: { requestId: new NotEqual("uuid-123") },
+        } as any);
+        expect(statement.query).toBe(
+          "AND {p0:Identifier}[{p1:String}] != {p2:String}",
+        );
+      });
+
+      test("uses mapContains+subscript for IsNull wrapper", () => {
+        const statement: Statement = mapGenerator.toWhereStatement({
+          attributes: { requestId: new IsNull() },
+        } as any);
+        expect(statement.query).toBe(
+          "AND ((NOT mapContains({p0:Identifier}, {p1:String})) OR {p2:Identifier}[{p3:String}] = '')",
+        );
+      });
+
+      test("uses mapContains+subscript for NotNull wrapper", () => {
+        const statement: Statement = mapGenerator.toWhereStatement({
+          attributes: { requestId: new NotNull() },
+        } as any);
+        expect(statement.query).toBe(
+          "AND mapContains({p0:Identifier}, {p1:String}) AND {p2:Identifier}[{p3:String}] != ''",
+        );
+      });
+
+      test("uses direct map subscript for numeric GreaterThan wrapper", () => {
+        const statement: Statement = mapGenerator.toWhereStatement({
+          attributes: { httpStatus: new GreaterThan(500) },
+        } as any);
+        expect(statement.query).toBe(
+          "AND toFloat64OrNull({p0:Identifier}[{p1:String}]) > {p2:Int32}",
+        );
+      });
+
+      test("keeps case-insensitive arrayExists for Search wrapper", () => {
+        const statement: Statement = mapGenerator.toWhereStatement({
+          attributes: { requestId: new Search("uuid") },
+        } as any);
+        /*
+         * Search comes from the user-typed search bar — keep the
+         * case-insensitive ILIKE form so the user doesn't have to
+         * remember whether the stored key is `requestId` or
+         * `requestid`.
+         */
+        expect(statement.query).toContain("arrayExists");
+        expect(statement.query).toContain("lowerUTF8");
+        expect(statement.query).toContain("ILIKE");
+      });
+
+      test("keeps case-insensitive arrayExists for StartsWith wrapper", () => {
+        const statement: Statement = mapGenerator.toWhereStatement({
+          attributes: { requestId: new StartsWith("uuid") },
+        } as any);
+        expect(statement.query).toContain("arrayExists");
+        expect(statement.query).toContain("lowerUTF8");
+        expect(statement.query).toContain("ILIKE");
+      });
+    });
   });
 
   describe("toSelectStatement", () => {

package/Types/Metrics/MetricQueryConfigData.ts

@@ -20,4 +20,13 @@ export default interface MetricQueryConfigData {
   yAxisValueFormatter?: ((value: number) => string) | undefined;
   warningThreshold?: number | undefined;
   criticalThreshold?: number | undefined;
+  /*
+   * When true, the post-aggregation series points are transformed into
+   * a per-second rate of change: `(value - previousValue) / Δt`. This is
+   * the right view for OTel cumulative counters (e.g. `system.disk.io`,
+   * `system.network.io`) — without it, the chart plots monotonically
+   * growing bytes-since-process-start. Negative deltas (counter resets
+   * on agent restart) are clamped to 0.
+   */
+  transformAsRate?: boolean | undefined;
 }