@oneuptime/common 10.0.86 → 10.0.89

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/Server/Services/TelemetryAttributeService.ts

@@ -3,6 +3,7 @@ import TelemetryType from "../../Types/Telemetry/TelemetryType";
 import LogDatabaseService from "./LogService";
 import MetricDatabaseService from "./MetricService";
 import SpanDatabaseService from "./SpanService";
+import ExceptionInstanceService from "./ExceptionInstanceService";
 import TableColumnType from "../../Types/AnalyticsDatabase/TableColumnType";
 import { JSONObject } from "../../Types/JSON";
 import ObjectID from "../../Types/ObjectID";
@@ -18,7 +19,12 @@ type TelemetrySource = {
   service: AnalyticsDatabaseService<any>;
   tableName: string;
   attributesColumn: string;
-  attributeKeysColumn: string;
+  /*
+   * Some tables (e.g. ExceptionInstance) don't have a separate
+   * attributeKeys array column — only the attributes map. Leave this
+   * undefined for those; the SQL falls back to mapKeys(attributes).
+   */
+  attributeKeysColumn?: string | undefined;
   timeColumn: string;
 };
 
@@ -62,6 +68,14 @@ export class TelemetryAttributeService {
           attributeKeysColumn: "attributeKeys",
           timeColumn: "startTime",
         };
+      case TelemetryType.Exception:
+        return {
+          service: ExceptionInstanceService,
+          tableName: ExceptionInstanceService.model.tableName,
+          attributesColumn: "attributes",
+          // ExceptionInstance has no attributeKeys column.
+          timeColumn: "time",
+        };
       default:
         return null;
     }
@@ -225,14 +239,21 @@ export class TelemetryAttributeService {
     projectId: ObjectID;
     tableName: string;
     attributesColumn: string;
-    attributeKeysColumn: string;
+    attributeKeysColumn?: string | undefined;
     timeColumn: string;
     metricName?: string | undefined;
   }): Statement {
     const lookbackStartDate: Date =
       TelemetryAttributeService.getLookbackStartDate();
 
-    const statement: Statement = SQL`
+    /*
+     * If the source has a denormalized attributeKeys array column, prefer it
+     * (avoids materializing every row's map). Otherwise fall back to
+     * mapKeys(attributes) — slower but works for tables that don't carry
+     * the precomputed array (e.g. ExceptionInstance).
+     */
+    const statement: Statement = data.attributeKeysColumn
+      ? SQL`
       WITH filtered AS (
         SELECT arrayJoin(
             if(
@@ -250,6 +271,19 @@ export class TelemetryAttributeService {
             NOT empty(${data.attributeKeysColumn}) OR
             NOT empty(${data.attributesColumn})
           )
+          AND ${data.timeColumn} >= ${{
+            type: TableColumnType.Date,
+            value: lookbackStartDate,
+          }}`
+      : SQL`
+      WITH filtered AS (
+        SELECT arrayJoin(mapKeys(${data.attributesColumn})) AS attribute
+        FROM ${data.tableName}
+        WHERE projectId = ${{
+          type: TableColumnType.ObjectID,
+          value: data.projectId,
+        }}
+          AND NOT empty(${data.attributesColumn})
           AND ${data.timeColumn} >= ${{
             type: TableColumnType.Date,
             value: lookbackStartDate,

package/Server/Utils/AnalyticsDatabase/StatementGenerator.ts

@@ -15,6 +15,7 @@ import AnalyticsTableColumn, {
   SkipIndexType,
 } from "../../../Types/AnalyticsDatabase/TableColumn";
 import TableColumnType from "../../../Types/AnalyticsDatabase/TableColumnType";
+import EqualTo from "../../../Types/BaseDatabase/EqualTo";
 import GreaterThan from "../../../Types/BaseDatabase/GreaterThan";
 import GreaterThanOrEqual from "../../../Types/BaseDatabase/GreaterThanOrEqual";
 import InBetween from "../../../Types/BaseDatabase/InBetween";
@@ -25,7 +26,11 @@ import LessThanOrEqual from "../../../Types/BaseDatabase/LessThanOrEqual";
 import GreaterThanOrNull from "../../../Types/BaseDatabase/GreaterThanOrNull";
 import LessThanOrNull from "../../../Types/BaseDatabase/LessThanOrNull";
 import NotEqual from "../../../Types/BaseDatabase/NotEqual";
+import NotContains from "../../../Types/BaseDatabase/NotContains";
+import NotNull from "../../../Types/BaseDatabase/NotNull";
 import Search from "../../../Types/BaseDatabase/Search";
+import StartsWith from "../../../Types/BaseDatabase/StartsWith";
+import EndsWith from "../../../Types/BaseDatabase/EndsWith";
 import SortOrder from "../../../Types/BaseDatabase/SortOrder";
 import OneUptimeDate from "../../../Types/Date";
 import BadDataException from "../../../Types/Exception/BadDataException";
@@ -447,33 +452,195 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
         tableColumn.type === TableColumnType.MapStringString &&
         typeof value === "object"
       ) {
-        const mapValue: Record<string, string | Search<string>> =
-          value as Record<string, string | Search<string>>;
+        const mapValue: Record<string, unknown> = value as Record<
+          string,
+          unknown
+        >;
         for (const mapKey in mapValue) {
-          if (mapValue[mapKey] === undefined) {
+          const mapEntry: unknown = mapValue[mapKey];
+          if (mapEntry === undefined || mapEntry === null) {
             continue;
           }
-          if (mapValue[mapKey] instanceof Search) {
+
+          /*
+           * 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.
+           */
+          if (mapEntry instanceof IsNull) {
+            whereStatement.append(
+              SQL`AND ((NOT mapContains(${key}, ${{
+                value: mapKey,
+                type: TableColumnType.Text,
+              }})) OR ${key}[${{
+                value: mapKey,
+                type: TableColumnType.Text,
+              }}] = '')`,
+            );
+            continue;
+          }
+
+          if (mapEntry instanceof NotNull) {
+            whereStatement.append(
+              SQL`AND mapContains(${key}, ${{
+                value: mapKey,
+                type: TableColumnType.Text,
+              }}) AND ${key}[${{
+                value: mapKey,
+                type: TableColumnType.Text,
+              }}] != ''`,
+            );
+            continue;
+          }
+
+          if (mapEntry instanceof Search) {
+            whereStatement.append(
+              SQL`AND ${key}[${{
+                value: mapKey,
+                type: TableColumnType.Text,
+              }}] ILIKE ${{
+                value: mapEntry as Search<string>,
+                type: TableColumnType.Text,
+              }}`,
+            );
+            continue;
+          }
+
+          if (mapEntry instanceof NotContains) {
+            const literalValue: string = `%${(mapEntry.value as string) || ""}%`;
+            whereStatement.append(
+              SQL`AND ${key}[${{
+                value: mapKey,
+                type: TableColumnType.Text,
+              }}] NOT ILIKE ${{
+                value: literalValue,
+                type: TableColumnType.Text,
+              }}`,
+            );
+            continue;
+          }
+
+          if (mapEntry instanceof StartsWith) {
+            const literalValue: string = `${(mapEntry.value as string) || ""}%`;
+            whereStatement.append(
+              SQL`AND ${key}[${{
+                value: mapKey,
+                type: TableColumnType.Text,
+              }}] ILIKE ${{
+                value: literalValue,
+                type: TableColumnType.Text,
+              }}`,
+            );
+            continue;
+          }
+
+          if (mapEntry instanceof EndsWith) {
+            const literalValue: string = `%${(mapEntry.value as string) || ""}`;
             whereStatement.append(
               SQL`AND ${key}[${{
                 value: mapKey,
                 type: TableColumnType.Text,
               }}] ILIKE ${{
-                value: mapValue[mapKey] as Search<string>,
+                value: literalValue,
                 type: TableColumnType.Text,
               }}`,
             );
-          } else {
+            continue;
+          }
+
+          if (mapEntry instanceof NotEqual) {
+            whereStatement.append(
+              SQL`AND ${key}[${{
+                value: mapKey,
+                type: TableColumnType.Text,
+              }}] != ${{
+                value: String((mapEntry as NotEqual<string>).value ?? ""),
+                type: TableColumnType.Text,
+              }}`,
+            );
+            continue;
+          }
+
+          if (mapEntry instanceof EqualTo) {
             whereStatement.append(
               SQL`AND ${key}[${{
                 value: mapKey,
                 type: TableColumnType.Text,
               }}] = ${{
-                value: mapValue[mapKey] as string,
+                value: String((mapEntry as EqualTo<any>).value ?? ""),
                 type: TableColumnType.Text,
               }}`,
             );
+            continue;
           }
+
+          /*
+           * Map values are stored as text; cast to Float64 for numeric
+           * comparisons and skip rows where the cast fails (non-numeric).
+           */
+          if (mapEntry instanceof GreaterThan) {
+            whereStatement.append(
+              SQL`AND toFloat64OrNull(${key}[${{
+                value: mapKey,
+                type: TableColumnType.Text,
+              }}]) > ${{
+                value: Number((mapEntry as GreaterThan<any>).value),
+                type: TableColumnType.Number,
+              }}`,
+            );
+            continue;
+          }
+
+          if (mapEntry instanceof GreaterThanOrEqual) {
+            whereStatement.append(
+              SQL`AND toFloat64OrNull(${key}[${{
+                value: mapKey,
+                type: TableColumnType.Text,
+              }}]) >= ${{
+                value: Number((mapEntry as GreaterThanOrEqual<any>).value),
+                type: TableColumnType.Number,
+              }}`,
+            );
+            continue;
+          }
+
+          if (mapEntry instanceof LessThan) {
+            whereStatement.append(
+              SQL`AND toFloat64OrNull(${key}[${{
+                value: mapKey,
+                type: TableColumnType.Text,
+              }}]) < ${{
+                value: Number((mapEntry as LessThan<any>).value),
+                type: TableColumnType.Number,
+              }}`,
+            );
+            continue;
+          }
+
+          if (mapEntry instanceof LessThanOrEqual) {
+            whereStatement.append(
+              SQL`AND toFloat64OrNull(${key}[${{
+                value: mapKey,
+                type: TableColumnType.Text,
+              }}]) <= ${{
+                value: Number((mapEntry as LessThanOrEqual<any>).value),
+                type: TableColumnType.Number,
+              }}`,
+            );
+            continue;
+          }
+
+          // Bare string/number/boolean — back-compat with existing data.
+          whereStatement.append(
+            SQL`AND ${key}[${{
+              value: mapKey,
+              type: TableColumnType.Text,
+            }}] = ${{
+              value: String(mapEntry),
+              type: TableColumnType.Text,
+            }}`,
+          );
         }
       } else if (
         (tableColumn.type === TableColumnType.JSON ||

package/Tests/Types/Date.test.ts

@@ -250,4 +250,50 @@ describe("class OneUptimeDate", () => {
       expect(result[0]).not.toContain("EST");
     });
   });
+
+  describe("getDateAsFormattedArrayInMultipleTimezones default timezones", () => {
+    test("defaults include UTC, London, New York, LA, Kolkata, Sydney", () => {
+      const result: Array<string> =
+        OneUptimeDate.getDateAsFormattedArrayInMultipleTimezones({
+          date: new Date("2026-07-15T17:00:00Z"),
+          use12HourFormat: true,
+        });
+      expect(result).toHaveLength(6);
+      expect(result[0]).toContain("UTC");
+    });
+
+    test("summer (DST) event shows EDT and BST in defaults, not EST or GMT", () => {
+      /*
+       * Apr 27 2026 21:30 UTC — both US and UK are in DST. Use word
+       * boundaries so AEST/AEDT (Sydney) doesn't match EST/EDT.
+       */
+      const result: Array<string> =
+        OneUptimeDate.getDateAsFormattedArrayInMultipleTimezones({
+          date: new Date("2026-04-27T21:30:00Z"),
+          use12HourFormat: true,
+        });
+      const joined: string = result.join("\n");
+      expect(joined).toMatch(/\bEDT\b/);
+      expect(joined).toMatch(/\bBST\b/);
+      expect(joined).not.toMatch(/\bEST\b/);
+      expect(joined).not.toMatch(/\bGMT\b/);
+    });
+
+    test("winter (no DST) event shows EST and GMT in defaults, not EDT or BST", () => {
+      /*
+       * Jan 15 2026 17:00 UTC — both US and UK are on standard time. Use
+       * word boundaries so AEDT (Sydney) doesn't match EDT.
+       */
+      const result: Array<string> =
+        OneUptimeDate.getDateAsFormattedArrayInMultipleTimezones({
+          date: new Date("2026-01-15T17:00:00Z"),
+          use12HourFormat: true,
+        });
+      const joined: string = result.join("\n");
+      expect(joined).toMatch(/\bEST\b/);
+      expect(joined).toMatch(/\bGMT\b/);
+      expect(joined).not.toMatch(/\bEDT\b/);
+      expect(joined).not.toMatch(/\bBST\b/);
+    });
+  });
 });

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/Date.ts

@@ -1385,13 +1385,18 @@ export default class OneUptimeDate {
       formatstring = "MMM DD, YYYY";
     }
 
-    // convert this date into GMT, EST, PST, IST, ACT with moment
     const timezoneDates: Array<string> = [];
 
     if (!timezones || timezones.length === 0) {
+      /*
+       * Use IANA region zones (not fixed-offset zones like "EST") so the
+       * abbreviation reflects DST at the event's date — e.g. EST/EDT for
+       * America/New_York and GMT/BST for Europe/London.
+       */
       timezones = [
         Timezone.UTC,
-        Timezone.EST,
+        Timezone.EuropeLondon,
+        Timezone.AmericaNew_York,
         Timezone.AmericaLos_Angeles,
         Timezone.AsiaKolkata,
         Timezone.AustraliaSydney,
@@ -1416,7 +1421,7 @@ export default class OneUptimeDate {
   public static getDateAsFormattedHTMLInMultipleTimezones(data: {
     date: string | Date;
     onlyShowDate?: boolean;
-    timezones?: Array<Timezone> | undefined; // if this is skipped, then it will show the default timezones in the order of UTC, EST, PST, IST, ACT
+    timezones?: Array<Timezone> | undefined; // if skipped, defaults to UTC, Europe/London, America/New_York, America/Los_Angeles, Asia/Kolkata, Australia/Sydney (DST-aware)
     use12HourFormat?: boolean | undefined;
   }): string {
     const date: string | Date = data.date;
@@ -1435,7 +1440,7 @@ export default class OneUptimeDate {
   public static getDateAsFormattedStringInMultipleTimezones(data: {
     date: string | Date;
     onlyShowDate?: boolean | undefined;
-    timezones?: Array<Timezone> | undefined; // if this is skipped, then it will show the default timezones in the order of UTC, EST, PST, IST, ACT
+    timezones?: Array<Timezone> | undefined; // if skipped, defaults to UTC, Europe/London, America/New_York, America/Los_Angeles, Asia/Kolkata, Australia/Sydney (DST-aware)
     use12HourFormat?: boolean | undefined;
   }): string {
     const date: string | Date = data.date;