@oneuptime/common 10.0.29 → 10.0.31

package/Server/API/TelemetryAPI.ts

@@ -16,6 +16,12 @@ import LogAggregationService, {
   HistogramRequest,
   FacetValue,
   FacetRequest,
+  AnalyticsRequest,
+  AnalyticsChartType,
+  AnalyticsAggregation,
+  AnalyticsTimeseriesRow,
+  AnalyticsTopItem,
+  AnalyticsTableRow,
 } from "../Services/LogAggregationService";
 import ObjectID from "../../Types/ObjectID";
 import OneUptimeDate from "../../Types/Date";
@@ -264,6 +270,146 @@ router.post(
   },
 );
 
+// --- Log Analytics Endpoint ---
+
+router.post(
+  "/telemetry/logs/analytics",
+  UserMiddleware.getUserMiddleware,
+  async (
+    req: ExpressRequest,
+    res: ExpressResponse,
+    next: NextFunction,
+  ): Promise<void> => {
+    try {
+      const databaseProps: DatabaseCommonInteractionProps =
+        await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+      if (!databaseProps?.tenantId) {
+        return Response.sendErrorResponse(
+          req,
+          res,
+          new BadDataException("Invalid Project ID"),
+        );
+      }
+
+      const body: JSONObject = req.body as JSONObject;
+
+      const chartType: AnalyticsChartType =
+        (body["chartType"] as AnalyticsChartType) || "timeseries";
+
+      if (!["timeseries", "toplist", "table"].includes(chartType)) {
+        return Response.sendErrorResponse(
+          req,
+          res,
+          new BadDataException("Invalid chartType"),
+        );
+      }
+
+      const aggregation: AnalyticsAggregation =
+        (body["aggregation"] as AnalyticsAggregation) || "count";
+
+      if (!["count", "unique"].includes(aggregation)) {
+        return Response.sendErrorResponse(
+          req,
+          res,
+          new BadDataException("Invalid aggregation"),
+        );
+      }
+
+      const startTime: Date = body["startTime"]
+        ? OneUptimeDate.fromString(body["startTime"] as string)
+        : OneUptimeDate.addRemoveHours(OneUptimeDate.getCurrentDate(), -1);
+
+      const endTime: Date = body["endTime"]
+        ? OneUptimeDate.fromString(body["endTime"] as string)
+        : OneUptimeDate.getCurrentDate();
+
+      const bucketSizeInMinutes: number =
+        (body["bucketSizeInMinutes"] as number) ||
+        computeDefaultBucketSize(startTime, endTime);
+
+      const serviceIds: Array<ObjectID> | undefined = body["serviceIds"]
+        ? (body["serviceIds"] as Array<string>).map((id: string) => {
+            return new ObjectID(id);
+          })
+        : undefined;
+
+      const severityTexts: Array<string> | undefined = body["severityTexts"]
+        ? (body["severityTexts"] as Array<string>)
+        : undefined;
+
+      const bodySearchText: string | undefined = body["bodySearchText"]
+        ? (body["bodySearchText"] as string)
+        : undefined;
+
+      const traceIds: Array<string> | undefined = body["traceIds"]
+        ? (body["traceIds"] as Array<string>)
+        : undefined;
+
+      const spanIds: Array<string> | undefined = body["spanIds"]
+        ? (body["spanIds"] as Array<string>)
+        : undefined;
+
+      const groupBy: Array<string> | undefined = body["groupBy"]
+        ? (body["groupBy"] as Array<string>)
+        : undefined;
+
+      const aggregationField: string | undefined = body["aggregationField"]
+        ? (body["aggregationField"] as string)
+        : undefined;
+
+      const limit: number | undefined = body["limit"]
+        ? (body["limit"] as number)
+        : undefined;
+
+      const request: AnalyticsRequest = {
+        projectId: databaseProps.tenantId,
+        startTime,
+        endTime,
+        bucketSizeInMinutes,
+        chartType,
+        groupBy,
+        aggregation,
+        aggregationField,
+        serviceIds,
+        severityTexts,
+        bodySearchText,
+        traceIds,
+        spanIds,
+        limit,
+      };
+
+      if (chartType === "timeseries") {
+        const data: Array<AnalyticsTimeseriesRow> =
+          await LogAggregationService.getAnalyticsTimeseries(request);
+
+        return Response.sendJsonObjectResponse(req, res, {
+          data: data as unknown as JSONObject,
+        });
+      }
+
+      if (chartType === "toplist") {
+        const data: Array<AnalyticsTopItem> =
+          await LogAggregationService.getAnalyticsTopList(request);
+
+        return Response.sendJsonObjectResponse(req, res, {
+          data: data as unknown as JSONObject,
+        });
+      }
+
+      // table
+      const data: Array<AnalyticsTableRow> =
+        await LogAggregationService.getAnalyticsTable(request);
+
+      return Response.sendJsonObjectResponse(req, res, {
+        data: data as unknown as JSONObject,
+      });
+    } catch (err: unknown) {
+      next(err);
+    }
+  },
+);
+
 // --- Helpers ---
 
 function computeDefaultBucketSize(startTime: Date, endTime: Date): number {

package/Server/Services/LogAggregationService.ts

@@ -44,6 +44,42 @@ export interface FacetRequest {
   spanIds?: Array<string> | undefined;
 }
 
+export type AnalyticsChartType = "timeseries" | "toplist" | "table";
+export type AnalyticsAggregation = "count" | "unique";
+
+export interface AnalyticsRequest {
+  projectId: ObjectID;
+  startTime: Date;
+  endTime: Date;
+  bucketSizeInMinutes: number;
+  chartType: AnalyticsChartType;
+  groupBy?: Array<string> | undefined;
+  aggregation: AnalyticsAggregation;
+  aggregationField?: string | undefined;
+  serviceIds?: Array<ObjectID> | undefined;
+  severityTexts?: Array<string> | undefined;
+  bodySearchText?: string | undefined;
+  traceIds?: Array<string> | undefined;
+  spanIds?: Array<string> | undefined;
+  limit?: number | undefined;
+}
+
+export interface AnalyticsTimeseriesRow {
+  time: string;
+  count: number;
+  groupValues: Record<string, string>;
+}
+
+export interface AnalyticsTopItem {
+  value: string;
+  count: number;
+}
+
+export interface AnalyticsTableRow {
+  groupValues: Record<string, string>;
+  count: number;
+}
+
 export class LogAggregationService {
   private static readonly DEFAULT_FACET_LIMIT: number = 500;
   private static readonly TABLE_NAME: string = "LogItem";
@@ -197,6 +233,357 @@ export class LogAggregationService {
     return statement;
   }
 
+  private static readonly DEFAULT_ANALYTICS_LIMIT: number = 10;
+  private static readonly MAX_GROUP_BY_DIMENSIONS: number = 2;
+
+  @CaptureSpan()
+  public static async getAnalyticsTimeseries(
+    request: AnalyticsRequest,
+  ): Promise<Array<AnalyticsTimeseriesRow>> {
+    const statement: Statement =
+      LogAggregationService.buildAnalyticsTimeseriesStatement(request);
+
+    const dbResult: Results = await LogDatabaseService.executeQuery(statement);
+    const response: DbJSONResponse = await dbResult.json<{
+      data?: Array<JSONObject>;
+    }>();
+
+    const rows: Array<JSONObject> = response.data || [];
+    const groupByKeys: Array<string> = request.groupBy || [];
+
+    return rows.map((row: JSONObject): AnalyticsTimeseriesRow => {
+      const groupValues: Record<string, string> = {};
+
+      for (const key of groupByKeys) {
+        const alias: string = LogAggregationService.groupByAlias(key);
+        groupValues[key] = String(row[alias] || "");
+      }
+
+      return {
+        time: String(row["bucket"] || ""),
+        count: Number(row["cnt"] || 0),
+        groupValues,
+      };
+    });
+  }
+
+  @CaptureSpan()
+  public static async getAnalyticsTopList(
+    request: AnalyticsRequest,
+  ): Promise<Array<AnalyticsTopItem>> {
+    if (!request.groupBy || request.groupBy.length === 0) {
+      throw new BadDataException(
+        "groupBy with at least one dimension is required for top list",
+      );
+    }
+
+    const statement: Statement =
+      LogAggregationService.buildAnalyticsTopListStatement(request);
+
+    const dbResult: Results = await LogDatabaseService.executeQuery(statement);
+    const response: DbJSONResponse = await dbResult.json<{
+      data?: Array<JSONObject>;
+    }>();
+
+    const rows: Array<JSONObject> = response.data || [];
+
+    return rows
+      .map((row: JSONObject): AnalyticsTopItem => {
+        return {
+          value: String(row["val"] || ""),
+          count: Number(row["cnt"] || 0),
+        };
+      })
+      .filter((item: AnalyticsTopItem): boolean => {
+        return item.value.length > 0;
+      });
+  }
+
+  @CaptureSpan()
+  public static async getAnalyticsTable(
+    request: AnalyticsRequest,
+  ): Promise<Array<AnalyticsTableRow>> {
+    if (!request.groupBy || request.groupBy.length === 0) {
+      throw new BadDataException(
+        "groupBy with at least one dimension is required for table",
+      );
+    }
+
+    const statement: Statement =
+      LogAggregationService.buildAnalyticsTableStatement(request);
+
+    const dbResult: Results = await LogDatabaseService.executeQuery(statement);
+    const response: DbJSONResponse = await dbResult.json<{
+      data?: Array<JSONObject>;
+    }>();
+
+    const rows: Array<JSONObject> = response.data || [];
+    const groupByKeys: Array<string> = request.groupBy;
+
+    return rows.map((row: JSONObject): AnalyticsTableRow => {
+      const groupValues: Record<string, string> = {};
+
+      for (const key of groupByKeys) {
+        const alias: string = LogAggregationService.groupByAlias(key);
+        groupValues[key] = String(row[alias] || "");
+      }
+
+      return {
+        groupValues,
+        count: Number(row["cnt"] || 0),
+      };
+    });
+  }
+
+  private static groupByAlias(key: string): string {
+    if (LogAggregationService.isTopLevelColumn(key)) {
+      return key;
+    }
+
+    // For attribute keys, use a sanitized alias
+    return `attr_${key.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+  }
+
+  private static appendGroupBySelect(
+    statement: Statement,
+    groupByKeys: Array<string>,
+  ): void {
+    for (const key of groupByKeys) {
+      LogAggregationService.validateFacetKey(key);
+
+      if (LogAggregationService.isTopLevelColumn(key)) {
+        statement.append(`, toString(${key}) AS ${key}`);
+      } else {
+        const alias: string = LogAggregationService.groupByAlias(key);
+        statement.append(
+          SQL`, JSONExtractRaw(attributes, ${{
+            type: TableColumnType.Text,
+            value: key,
+          }}) AS ${alias}`,
+        );
+      }
+    }
+  }
+
+  private static appendGroupByClause(
+    statement: Statement,
+    groupByKeys: Array<string>,
+  ): void {
+    for (const key of groupByKeys) {
+      if (LogAggregationService.isTopLevelColumn(key)) {
+        statement.append(`, ${key}`);
+      } else {
+        const alias: string = LogAggregationService.groupByAlias(key);
+        statement.append(`, ${alias}`);
+      }
+    }
+  }
+
+  private static getAggregationExpression(request: AnalyticsRequest): string {
+    if (request.aggregation === "unique" && request.aggregationField) {
+      LogAggregationService.validateFacetKey(request.aggregationField);
+
+      if (LogAggregationService.isTopLevelColumn(request.aggregationField)) {
+        return `uniqExact(${request.aggregationField})`;
+      }
+
+      return `uniqExact(JSONExtractRaw(attributes, '${request.aggregationField.replace(/'/g, "\\'")}'))`;
+    }
+
+    return "count()";
+  }
+
+  private static validateGroupBy(groupBy: Array<string> | undefined): void {
+    if (!groupBy) {
+      return;
+    }
+
+    if (groupBy.length > LogAggregationService.MAX_GROUP_BY_DIMENSIONS) {
+      throw new BadDataException(
+        `groupBy supports at most ${LogAggregationService.MAX_GROUP_BY_DIMENSIONS} dimensions`,
+      );
+    }
+
+    for (const key of groupBy) {
+      LogAggregationService.validateFacetKey(key);
+    }
+  }
+
+  private static buildAnalyticsTimeseriesStatement(
+    request: AnalyticsRequest,
+  ): Statement {
+    LogAggregationService.validateGroupBy(request.groupBy);
+
+    const intervalSeconds: number = request.bucketSizeInMinutes * 60;
+    const aggExpr: string =
+      LogAggregationService.getAggregationExpression(request);
+
+    const statement: Statement = SQL`
+      SELECT
+        toStartOfInterval(time, INTERVAL ${{
+          type: TableColumnType.Number,
+          value: intervalSeconds,
+        }} SECOND) AS bucket`;
+
+    statement.append(`, ${aggExpr} AS cnt`);
+
+    if (request.groupBy && request.groupBy.length > 0) {
+      LogAggregationService.appendGroupBySelect(statement, request.groupBy);
+    }
+
+    statement.append(
+      SQL`
+      FROM ${LogAggregationService.TABLE_NAME}
+      WHERE projectId = ${{
+        type: TableColumnType.ObjectID,
+        value: request.projectId,
+      }}
+        AND time >= ${{
+          type: TableColumnType.Date,
+          value: request.startTime,
+        }}
+        AND time <= ${{
+          type: TableColumnType.Date,
+          value: request.endTime,
+        }}`,
+    );
+
+    LogAggregationService.appendCommonFilters(statement, request);
+
+    statement.append(" GROUP BY bucket");
+
+    if (request.groupBy && request.groupBy.length > 0) {
+      LogAggregationService.appendGroupByClause(statement, request.groupBy);
+    }
+
+    statement.append(" ORDER BY bucket ASC");
+
+    return statement;
+  }
+
+  private static buildAnalyticsTopListStatement(
+    request: AnalyticsRequest,
+  ): Statement {
+    const groupByKey: string = request.groupBy![0]!;
+    LogAggregationService.validateFacetKey(groupByKey);
+
+    const limit: number =
+      request.limit ?? LogAggregationService.DEFAULT_ANALYTICS_LIMIT;
+    const aggExpr: string =
+      LogAggregationService.getAggregationExpression(request);
+
+    const isTopLevel: boolean =
+      LogAggregationService.isTopLevelColumn(groupByKey);
+
+    const statement: Statement = new Statement();
+
+    if (isTopLevel) {
+      statement.append(
+        `SELECT toString(${groupByKey}) AS val, ${aggExpr} AS cnt FROM ${LogAggregationService.TABLE_NAME}`,
+      );
+    } else {
+      statement.append(`SELECT JSONExtractRaw(attributes, `);
+      statement.append(
+        SQL`${{
+          type: TableColumnType.Text,
+          value: groupByKey,
+        }}`,
+      );
+      statement.append(
+        `) AS val, ${aggExpr} AS cnt FROM ${LogAggregationService.TABLE_NAME}`,
+      );
+    }
+
+    statement.append(
+      SQL` WHERE projectId = ${{
+        type: TableColumnType.ObjectID,
+        value: request.projectId,
+      }} AND time >= ${{
+        type: TableColumnType.Date,
+        value: request.startTime,
+      }} AND time <= ${{
+        type: TableColumnType.Date,
+        value: request.endTime,
+      }}`,
+    );
+
+    if (!isTopLevel) {
+      statement.append(
+        SQL` AND JSONHas(attributes, ${{
+          type: TableColumnType.Text,
+          value: groupByKey,
+        }}) = 1`,
+      );
+    }
+
+    LogAggregationService.appendCommonFilters(statement, request);
+
+    statement.append(
+      SQL` GROUP BY val ORDER BY cnt DESC LIMIT ${{
+        type: TableColumnType.Number,
+        value: limit,
+      }}`,
+    );
+
+    return statement;
+  }
+
+  private static buildAnalyticsTableStatement(
+    request: AnalyticsRequest,
+  ): Statement {
+    LogAggregationService.validateGroupBy(request.groupBy);
+
+    const groupByKeys: Array<string> = request.groupBy!;
+    const limit: number =
+      request.limit ?? LogAggregationService.DEFAULT_ANALYTICS_LIMIT;
+    const aggExpr: string =
+      LogAggregationService.getAggregationExpression(request);
+
+    const statement: Statement = new Statement();
+    statement.append(`SELECT ${aggExpr} AS cnt`);
+
+    LogAggregationService.appendGroupBySelect(statement, groupByKeys);
+
+    statement.append(
+      SQL`
+      FROM ${LogAggregationService.TABLE_NAME}
+      WHERE projectId = ${{
+        type: TableColumnType.ObjectID,
+        value: request.projectId,
+      }}
+        AND time >= ${{
+          type: TableColumnType.Date,
+          value: request.startTime,
+        }}
+        AND time <= ${{
+          type: TableColumnType.Date,
+          value: request.endTime,
+        }}`,
+    );
+
+    LogAggregationService.appendCommonFilters(statement, request);
+
+    // Build GROUP BY from aliases
+    const aliases: Array<string> = groupByKeys.map((key: string) => {
+      if (LogAggregationService.isTopLevelColumn(key)) {
+        return key;
+      }
+
+      return LogAggregationService.groupByAlias(key);
+    });
+
+    statement.append(` GROUP BY ${aliases.join(", ")}`);
+
+    statement.append(
+      SQL` ORDER BY cnt DESC LIMIT ${{
+        type: TableColumnType.Number,
+        value: limit,
+      }}`,
+    );
+
+    return statement;
+  }
+
   private static appendCommonFilters(
     statement: Statement,
     request: Pick<

package/Server/Types/Workflow/Components/BaseModel/OnTriggerBaseModel.ts

@@ -138,6 +138,21 @@ export default class OnTriggerBaseModel<
       select = JSONFunctions.parse(select) as Select<TBaseModel>;
     }
 
+    /*
+     * Convert string "true"/"false" values to booleans in select.
+     * Workflow arguments may pass select values as strings (e.g. "true")
+     * which causes TypeORM to iterate string characters as property indices.
+     */
+    if (select && typeof select === "object") {
+      for (const key in select) {
+        if ((select as any)[key] === "true") {
+          (select as any)[key] = true;
+        } else if ((select as any)[key] === "false") {
+          (select as any)[key] = false;
+        }
+      }
+    }
+
     const model: TBaseModel | null = await this.service!.findOneById({
       id: new ObjectID(data["_id"].toString()),
       props: {