@oneuptime/common 10.0.80 → 10.0.83

package/Models/AnalyticsModels/Metric.ts

@@ -20,6 +20,7 @@ export enum MetricPointType {
   Gauge = "Gauge",
   Histogram = "Histogram",
   ExponentialHistogram = "ExponentialHistogram",
+  Summary = "Summary",
 }
 
 export enum ServiceType {
@@ -501,8 +502,116 @@ export default class Metric extends AnalyticsBaseModel {
     const explicitBoundsColumn: AnalyticsTableColumn = new AnalyticsTableColumn(
       {
         key: "explicitBounds",
-        title: "Explicit Bonds",
-        description: "Explicit Bonds",
+        title: "Explicit Bounds",
+        description:
+          "Upper bounds (exclusive of the +inf overflow bucket) for each explicit-bucket histogram bucket. Stored as Float64 so sub-integer boundaries (e.g. 0.005, 0.01) survive ingest — the previous Array(Int64) representation silently truncated those to 0.",
+        required: true,
+        defaultValue: [],
+        type: TableColumnType.ArrayDecimal,
+        accessControl: {
+          read: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.ProjectMember,
+            Permission.ReadTelemetryServiceLog,
+          ],
+          create: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.ProjectMember,
+            Permission.CreateTelemetryServiceLog,
+          ],
+          update: [],
+        },
+      },
+    );
+
+    /*
+     * --- ExponentialHistogram-only columns ----------------------------------
+     * These are populated only when metricPointType = ExponentialHistogram.
+     * For other metric types they are left at their defaults (0 / []).
+     */
+
+    const scaleColumn: AnalyticsTableColumn = new AnalyticsTableColumn({
+      key: "scale",
+      title: "Scale",
+      description:
+        "ExponentialHistogram resolution. base = 2^(2^-scale); bucket index `i` covers (base^i, base^(i+1)].",
+      required: false,
+      type: TableColumnType.Number,
+      accessControl: {
+        read: [
+          Permission.ProjectOwner,
+          Permission.ProjectAdmin,
+          Permission.ProjectMember,
+          Permission.ReadTelemetryServiceLog,
+        ],
+        create: [
+          Permission.ProjectOwner,
+          Permission.ProjectAdmin,
+          Permission.ProjectMember,
+          Permission.CreateTelemetryServiceLog,
+        ],
+        update: [],
+      },
+    });
+
+    const zeroCountColumn: AnalyticsTableColumn = new AnalyticsTableColumn({
+      key: "zeroCount",
+      title: "Zero Count",
+      description:
+        "ExponentialHistogram count of values within the zero region (|v| <= zeroThreshold).",
+      required: false,
+      type: TableColumnType.BigNumber,
+      accessControl: {
+        read: [
+          Permission.ProjectOwner,
+          Permission.ProjectAdmin,
+          Permission.ProjectMember,
+          Permission.ReadTelemetryServiceLog,
+        ],
+        create: [
+          Permission.ProjectOwner,
+          Permission.ProjectAdmin,
+          Permission.ProjectMember,
+          Permission.CreateTelemetryServiceLog,
+        ],
+        update: [],
+      },
+    });
+
+    const positiveOffsetColumn: AnalyticsTableColumn = new AnalyticsTableColumn(
+      {
+        key: "positiveOffset",
+        title: "Positive Bucket Offset",
+        description:
+          "Bucket index of the first entry in positiveBucketCounts (ExponentialHistogram).",
+        required: false,
+        type: TableColumnType.Number,
+        accessControl: {
+          read: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.ProjectMember,
+            Permission.ReadTelemetryServiceLog,
+          ],
+          create: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.ProjectMember,
+            Permission.CreateTelemetryServiceLog,
+          ],
+          update: [],
+        },
+      },
+    );
+
+    const positiveBucketCountsColumn: AnalyticsTableColumn =
+      new AnalyticsTableColumn({
+        key: "positiveBucketCounts",
+        title: "Positive Bucket Counts",
+        description:
+          "Counts for the positive range of an ExponentialHistogram, indexed from positiveOffset.",
         required: true,
         defaultValue: [],
         type: TableColumnType.ArrayBigNumber,
@@ -521,9 +630,118 @@ export default class Metric extends AnalyticsBaseModel {
           ],
           update: [],
         },
+      });
+
+    const negativeOffsetColumn: AnalyticsTableColumn = new AnalyticsTableColumn(
+      {
+        key: "negativeOffset",
+        title: "Negative Bucket Offset",
+        description:
+          "Bucket index of the first entry in negativeBucketCounts (ExponentialHistogram).",
+        required: false,
+        type: TableColumnType.Number,
+        accessControl: {
+          read: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.ProjectMember,
+            Permission.ReadTelemetryServiceLog,
+          ],
+          create: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.ProjectMember,
+            Permission.CreateTelemetryServiceLog,
+          ],
+          update: [],
+        },
       },
     );
 
+    const negativeBucketCountsColumn: AnalyticsTableColumn =
+      new AnalyticsTableColumn({
+        key: "negativeBucketCounts",
+        title: "Negative Bucket Counts",
+        description:
+          "Counts for the negative range of an ExponentialHistogram, indexed from negativeOffset.",
+        required: true,
+        defaultValue: [],
+        type: TableColumnType.ArrayBigNumber,
+        accessControl: {
+          read: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.ProjectMember,
+            Permission.ReadTelemetryServiceLog,
+          ],
+          create: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.ProjectMember,
+            Permission.CreateTelemetryServiceLog,
+          ],
+          update: [],
+        },
+      });
+
+    /*
+     * --- Summary-only columns -----------------------------------------------
+     * Populated only when metricPointType = Summary. Two parallel arrays
+     * keyed by index (mirrors the bucketCounts/explicitBounds convention):
+     *   summaryQuantiles[i] in [0,1], summaryValues[i] is value at that quantile.
+     */
+
+    const summaryQuantilesColumn: AnalyticsTableColumn =
+      new AnalyticsTableColumn({
+        key: "summaryQuantiles",
+        title: "Summary Quantiles",
+        description:
+          "Quantile percentages in [0,1] for a Summary metric (parallel to summaryValues).",
+        required: true,
+        defaultValue: [],
+        type: TableColumnType.ArrayDecimal,
+        accessControl: {
+          read: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.ProjectMember,
+            Permission.ReadTelemetryServiceLog,
+          ],
+          create: [
+            Permission.ProjectOwner,
+            Permission.ProjectAdmin,
+            Permission.ProjectMember,
+            Permission.CreateTelemetryServiceLog,
+          ],
+          update: [],
+        },
+      });
+
+    const summaryValuesColumn: AnalyticsTableColumn = new AnalyticsTableColumn({
+      key: "summaryValues",
+      title: "Summary Values",
+      description:
+        "Values corresponding to each quantile in summaryQuantiles for a Summary metric.",
+      required: true,
+      defaultValue: [],
+      type: TableColumnType.ArrayDecimal,
+      accessControl: {
+        read: [
+          Permission.ProjectOwner,
+          Permission.ProjectAdmin,
+          Permission.ProjectMember,
+          Permission.ReadTelemetryServiceLog,
+        ],
+        create: [
+          Permission.ProjectOwner,
+          Permission.ProjectAdmin,
+          Permission.ProjectMember,
+          Permission.CreateTelemetryServiceLog,
+        ],
+        update: [],
+      },
+    });
+
     const traceIdColumn: AnalyticsTableColumn = new AnalyticsTableColumn({
       key: "traceId",
       title: "Trace ID",
@@ -647,6 +865,14 @@ export default class Metric extends AnalyticsBaseModel {
         maxColumn,
         bucketCountsColumn,
         explicitBoundsColumn,
+        scaleColumn,
+        zeroCountColumn,
+        positiveOffsetColumn,
+        positiveBucketCountsColumn,
+        negativeOffsetColumn,
+        negativeBucketCountsColumn,
+        summaryQuantilesColumn,
+        summaryValuesColumn,
         traceIdColumn,
         spanIdColumn,
         retentionDateColumn,
@@ -846,4 +1072,72 @@ export default class Metric extends AnalyticsBaseModel {
   public set retentionDate(v: Date | undefined) {
     this.setColumnValue("retentionDate", v);
   }
+
+  public get scale(): number | undefined {
+    return this.getColumnValue("scale") as number | undefined;
+  }
+
+  public set scale(v: number | undefined) {
+    this.setColumnValue("scale", v);
+  }
+
+  public get zeroCount(): number | undefined {
+    return this.getColumnValue("zeroCount") as number | undefined;
+  }
+
+  public set zeroCount(v: number | undefined) {
+    this.setColumnValue("zeroCount", v);
+  }
+
+  public get positiveOffset(): number | undefined {
+    return this.getColumnValue("positiveOffset") as number | undefined;
+  }
+
+  public set positiveOffset(v: number | undefined) {
+    this.setColumnValue("positiveOffset", v);
+  }
+
+  public get positiveBucketCounts(): Array<number> | undefined {
+    return this.getColumnValue("positiveBucketCounts") as
+      | Array<number>
+      | undefined;
+  }
+
+  public set positiveBucketCounts(v: Array<number> | undefined) {
+    this.setColumnValue("positiveBucketCounts", v);
+  }
+
+  public get negativeOffset(): number | undefined {
+    return this.getColumnValue("negativeOffset") as number | undefined;
+  }
+
+  public set negativeOffset(v: number | undefined) {
+    this.setColumnValue("negativeOffset", v);
+  }
+
+  public get negativeBucketCounts(): Array<number> | undefined {
+    return this.getColumnValue("negativeBucketCounts") as
+      | Array<number>
+      | undefined;
+  }
+
+  public set negativeBucketCounts(v: Array<number> | undefined) {
+    this.setColumnValue("negativeBucketCounts", v);
+  }
+
+  public get summaryQuantiles(): Array<number> | undefined {
+    return this.getColumnValue("summaryQuantiles") as Array<number> | undefined;
+  }
+
+  public set summaryQuantiles(v: Array<number> | undefined) {
+    this.setColumnValue("summaryQuantiles", v);
+  }
+
+  public get summaryValues(): Array<number> | undefined {
+    return this.getColumnValue("summaryValues") as Array<number> | undefined;
+  }
+
+  public set summaryValues(v: Array<number> | undefined) {
+    this.setColumnValue("summaryValues", v);
+  }
 }

package/Server/Services/MetricService.ts

@@ -1,10 +1,235 @@
 import ClickhouseDatabase from "../Infrastructure/ClickhouseDatabase";
 import AnalyticsDatabaseService from "./AnalyticsDatabaseService";
-import MetricSum from "../../Models/AnalyticsModels/Metric";
+import Metric from "../../Models/AnalyticsModels/Metric";
+import AggregateBy, {
+  AggregateUtil,
+} from "../Types/AnalyticsDatabase/AggregateBy";
+import { SQL, Statement } from "../Utils/AnalyticsDatabase/Statement";
+import {
+  getPercentileLevel,
+  isPercentileAggregation,
+} from "../../Types/BaseDatabase/AggregationType";
+import TableColumnType from "../../Types/AnalyticsDatabase/TableColumnType";
+import logger, { LogAttributes } from "../Utils/Logger";
 
-export class MetricService extends AnalyticsDatabaseService<MetricSum> {
+export class MetricService extends AnalyticsDatabaseService<Metric> {
   public constructor(clickhouseDatabase?: ClickhouseDatabase | undefined) {
-    super({ modelType: MetricSum, database: clickhouseDatabase });
+    super({ modelType: Metric, database: clickhouseDatabase });
+  }
+
+  /**
+   * Histogram-aware aggregation override.
+   *
+   * For non-percentile aggregations (Sum/Avg/Min/Max/Count) we delegate
+   * to the base implementation. For percentile aggregations
+   * (P50/P90/P95/P99) we build a subquery that fans each metric row out
+   * into one or more `(midpoint, weight)` samples — derived from
+   * histogram buckets when present — and then runs
+   * `quantileExactWeighted` over the fanned-out distribution. This means
+   * a P95 of `http.server.request.duration` returns a real
+   * bucket-derived 95th percentile of observed values, not the 95th
+   * percentile of per-row `sum`s.
+   *
+   * Per `metricPointType` the fanout is:
+   *
+   *   Histogram             -> one (midpoint, count) per explicit bucket;
+   *                            midpoint = (lower + upper) / 2, with the
+   *                            implicit -inf/+inf buckets approximated
+   *                            against the nearest bound.
+   *   ExponentialHistogram  -> one (geomean, count) per positive bucket;
+   *                            base = 2^(2^-scale); bucket index `k` is
+   *                            `positiveOffset + i - 1` (1-indexed) and
+   *                            we use the geometric midpoint
+   *                            base^(k + 0.5). Negative buckets are
+   *                            currently ignored (rare in practice and
+   *                            would require a separate fanout).
+   *   Summary               -> exactly one sample: the value at the
+   *                            stored quantile closest to (and >=) the
+   *                            target `p`, weighted 1; falls back to the
+   *                            highest stored quantile when nothing
+   *                            covers `p`.
+   *   Sum / Gauge / unknown -> raw `value` weighted 1 (same as the
+   *                            generic `quantile(p)(value)` path).
+   */
+  public override toAggregateStatement(aggregateBy: AggregateBy<Metric>): {
+    statement: Statement;
+    columns: Array<string>;
+  } {
+    if (!isPercentileAggregation(aggregateBy.aggregationType)) {
+      return super.toAggregateStatement(aggregateBy);
+    }
+
+    const percentileLevel: number | null = getPercentileLevel(
+      aggregateBy.aggregationType,
+    );
+    if (percentileLevel === null) {
+      return super.toAggregateStatement(aggregateBy);
+    }
+
+    if (!this.database) {
+      this.useDefaultDatabase();
+    }
+
+    const databaseName: string = this.database.getDatasourceOptions().database!;
+
+    const aggregationColumn: string =
+      aggregateBy.aggregateColumnName.toString();
+    const aggregationTimestampColumn: string =
+      aggregateBy.aggregationTimestampColumnName.toString();
+    const aggregationInterval: string = AggregateUtil.getAggregationInterval({
+      startDate: aggregateBy.startTimestamp!,
+      endDate: aggregateBy.endTimestamp!,
+    }).toLowerCase();
+
+    /*
+     * Group-by columns from the caller need to be carried through the
+     * inner subquery so the outer GROUP BY can reference them. Only
+     * columns that exist on the model are accepted (matches the base
+     * generator's safety net).
+     */
+    const groupByKeys: Array<string> = [];
+    if (aggregateBy.groupBy) {
+      for (const key of Object.keys(aggregateBy.groupBy)) {
+        if (!this.model.getTableColumn(key)) {
+          continue;
+        }
+        groupByKeys.push(key);
+      }
+    }
+
+    const whereStatement: Statement = this.statementGenerator.toWhereStatement(
+      aggregateBy.query,
+    );
+    const sortStatement: Statement = this.statementGenerator.toSortStatement(
+      aggregateBy.sort!,
+    );
+
+    /*
+     * Per-row fanout. The result of multiIf is `Array(Tuple(Float64,
+     * Float64))` — element 1 is the sample midpoint, element 2 is the
+     * weight (rounded to UInt64 in the outer SELECT for
+     * quantileExactWeighted). Each branch is guarded by a presence
+     * check so a row missing its expected payload (e.g. a zero-bucket
+     * histogram) silently drops to the scalar fallback rather than
+     * exploding.
+     */
+    const fanoutExpression: string = `
+      multiIf(
+        metricPointType = 'ExponentialHistogram' AND notEmpty(positiveBucketCounts),
+          arrayMap(
+            i -> tuple(
+              pow(
+                pow(2.0, pow(2.0, -toFloat64(coalesce(scale, 0)))),
+                toFloat64(coalesce(positiveOffset, 0)) + toFloat64(i) - 0.5
+              ),
+              toFloat64(positiveBucketCounts[i])
+            ),
+            arrayEnumerate(positiveBucketCounts)
+          ),
+        metricPointType = 'Histogram' AND notEmpty(bucketCounts),
+          arrayMap(
+            i -> tuple(
+              multiIf(
+                length(explicitBounds) = 0,
+                  toFloat64(coalesce(value, sum, 0)),
+                i = 1,
+                  toFloat64(explicitBounds[1]) / 2.0,
+                i > length(explicitBounds),
+                  toFloat64(explicitBounds[length(explicitBounds)]) * 1.5,
+                (toFloat64(explicitBounds[i - 1]) + toFloat64(explicitBounds[i])) / 2.0
+              ),
+              toFloat64(bucketCounts[i])
+            ),
+            arrayEnumerate(bucketCounts)
+          ),
+        metricPointType = 'Summary' AND notEmpty(summaryValues),
+          [tuple(
+            if(
+              arrayFirstIndex(q -> q >= ${percentileLevel}, summaryQuantiles) > 0,
+              summaryValues[arrayFirstIndex(q -> q >= ${percentileLevel}, summaryQuantiles)],
+              summaryValues[length(summaryValues)]
+            ),
+            1.0
+          )],
+        [tuple(toFloat64(coalesce(value, sum, 0)), 1.0)]
+      )
+    `;
+
+    /*
+     * Inner subquery: keeps the row's timestamp and any group-by
+     * columns, then fans the row into per-sample rows via arrayJoin.
+     * We use `__pcl_pair` so the column name doesn't collide with any
+     * model column should ClickHouse ever surface it through a tooling
+     * layer.
+     */
+    const innerSelectColumns: Array<string> = [aggregationTimestampColumn];
+    for (const key of groupByKeys) {
+      if (!innerSelectColumns.includes(key)) {
+        innerSelectColumns.push(key);
+      }
+    }
+
+    const innerSelectClause: string = `${innerSelectColumns.join(", ")}, arrayJoin(${fanoutExpression}) AS __pcl_pair`;
+
+    const statement: Statement = SQL``;
+
+    /*
+     * Outer SELECT: time bucket + weighted quantile + carry-forward
+     * group-by columns. Quantile weight must be UInt for
+     * quantileExactWeighted; we round to nearest integer (a count of
+     * 0.5 rounds to 0 which drops the sample, but bucket counts are
+     * always whole numbers in practice).
+     */
+    statement.append(
+      `SELECT quantileExactWeighted(${percentileLevel})(__pcl_pair.1, toUInt64(greatest(0, round(__pcl_pair.2)))) as ${aggregationColumn}, date_trunc('${aggregationInterval}', toStartOfInterval(${aggregationTimestampColumn}, INTERVAL 1 ${aggregationInterval})) as ${aggregationTimestampColumn}`,
+    );
+
+    for (const key of groupByKeys) {
+      statement.append(`, ${key}`);
+    }
+
+    statement.append(SQL` FROM (`);
+    statement.append(`SELECT ${innerSelectClause}`);
+    statement.append(
+      ` FROM ${databaseName}.${this.model.tableName} WHERE TRUE `,
+    );
+    statement.append(whereStatement);
+    statement.append(SQL`) `);
+
+    statement.append(SQL` GROUP BY `).append(`${aggregationTimestampColumn}`);
+    for (const key of groupByKeys) {
+      statement.append(`, ${key}`);
+    }
+
+    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,
+      }} `,
+    );
+
+    const columns: Array<string> = [
+      aggregationColumn,
+      aggregationTimestampColumn,
+      ...groupByKeys,
+    ];
+
+    logger.debug(`${this.model.tableName} Percentile Aggregate Statement`, {
+      tableName: this.model.tableName,
+    } as LogAttributes);
+    logger.debug(statement, {
+      tableName: this.model.tableName,
+    } as LogAttributes);
+
+    return { statement, columns };
   }
 }
 

package/Server/Utils/AnalyticsDatabase/StatementGenerator.ts

@@ -35,6 +35,7 @@ import AggregateBy, {
   AggregateUtil,
 } from "../../Types/AnalyticsDatabase/AggregateBy";
 import CaptureSpan from "../Telemetry/CaptureSpan";
+import { getPercentileLevel } from "../../../Types/BaseDatabase/AggregationType";
 
 export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
   public model!: TBaseModel;
@@ -275,6 +276,25 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
         .join(", ")}]`;
     }
 
+    if (column.type === TableColumnType.ArrayDecimal) {
+      value = `[${(value as Array<number>)
+        .map((v: number) => {
+          if (v && typeof v !== "number") {
+            v = parseFloat(v);
+            return isNaN(v) ? "NULL" : v;
+          }
+          /*
+           * Filter non-finite (NaN/+Inf/-Inf) -> NULL so ClickHouse Float64
+           * serialization succeeds (mirrors `toNumberOrNull` in OTLP ingest).
+           */
+          if (typeof v === "number" && !Number.isFinite(v)) {
+            return "NULL";
+          }
+          return v;
+        })
+        .join(", ")}]`;
+    }
+
     if (column.type === TableColumnType.MapStringString) {
       const mapObj: Record<string, string> = value as Record<string, string>;
       const entries: Array<string> = Object.entries(mapObj)
@@ -594,19 +614,37 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
     /*
      * EXAMPLE:
      * SELECT sum(Metric.value) as avg_value, date_trunc('hour', toStartOfInterval(createdAt, INTERVAL 1 hour)) as createdAt
+     *
+     * Percentile aggregations (P50/P90/P95/P99) compile to ClickHouse's
+     * `quantile(level)(column)`. This is the right thing for scalar
+     * columns (Span.duration, Metric.value when the metric is a Sum or
+     * Gauge, etc.). MetricService overrides this method when it has
+     * histogram bucket data so the percentile is computed from the
+     * actual sample distribution rather than from the per-row aggregated
+     * value.
      */
 
     const selectStatement: Statement = new Statement();
 
-    const aggregationMethod: string =
-      aggregateBy.aggregationType.toLocaleLowerCase();
     const aggregationInterval: string = AggregateUtil.getAggregationInterval({
       startDate: aggregateBy.startTimestamp!,
       endDate: aggregateBy.endTimestamp!,
     });
+    const aggregationColumn: string =
+      aggregateBy.aggregateColumnName.toString();
+    const aggregationTimestampColumn: string =
+      aggregateBy.aggregationTimestampColumnName.toString();
+
+    const percentileLevel: number | null = getPercentileLevel(
+      aggregateBy.aggregationType,
+    );
+    const aggregationExpression: string =
+      percentileLevel !== null
+        ? `quantile(${percentileLevel})(${aggregationColumn})`
+        : `${aggregateBy.aggregationType.toLocaleLowerCase()}(${aggregationColumn})`;
 
     selectStatement.append(
-      `${aggregationMethod}(${aggregateBy.aggregateColumnName.toString()}) as ${aggregateBy.aggregateColumnName.toString()}, date_trunc('${aggregationInterval.toLowerCase()}', toStartOfInterval(${aggregateBy.aggregationTimestampColumnName.toString()}, INTERVAL 1 ${aggregationInterval.toLowerCase()})) as ${aggregateBy.aggregationTimestampColumnName.toString()}`,
+      `${aggregationExpression} as ${aggregationColumn}, date_trunc('${aggregationInterval.toLowerCase()}', toStartOfInterval(${aggregationTimestampColumn}, INTERVAL 1 ${aggregationInterval.toLowerCase()})) as ${aggregationTimestampColumn}`,
     );
 
     const columns: Array<string> = [
@@ -745,6 +783,7 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
       "Array(String)": TableColumnType.ArrayText,
       "Array(Int32)": TableColumnType.ArrayNumber,
       "Array(Int64)": TableColumnType.ArrayBigNumber,
+      "Array(Float64)": TableColumnType.ArrayDecimal,
       "Map(String, String)": TableColumnType.MapStringString,
       JSON: TableColumnType.JSON, //JSONArray is also JSON
       Bool: TableColumnType.Boolean,
@@ -766,6 +805,7 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
       [TableColumnType.JSONArray]: SQL`String`, // we use JSON as a string because ClickHouse has really good JSON support for string types
       [TableColumnType.ArrayNumber]: SQL`Array(Int32)`,
       [TableColumnType.ArrayBigNumber]: SQL`Array(Int64)`,
+      [TableColumnType.ArrayDecimal]: SQL`Array(Float64)`,
       [TableColumnType.ArrayText]: SQL`Array(String)`,
       [TableColumnType.LongNumber]: SQL`Int128`,
       [TableColumnType.BigNumber]: SQL`Int64`,

package/Server/Utils/Express.ts

@@ -22,6 +22,11 @@ export const ExpressJson: GenericFunction = express.json;
 export const ExpressUrlEncoded: GenericFunction = express.urlencoded;
 export const ExpressRaw: GenericFunction = express.raw;
 
+export const createExpressApp: () => express.Application =
+  (): express.Application => {
+    return express();
+  };
+
 export type ProbeRequest = {
   id: ObjectID;
 };

package/Types/AnalyticsDatabase/TableColumnType.ts

@@ -16,6 +16,7 @@ enum ColumnType {
   Port = "Port",
   MapStringString = "Map(String, String)",
   ArrayBigNumber = "Array of Big Numbers",
+  ArrayDecimal = "Array of Decimals",
 }
 
 export default ColumnType;