@oneuptime/common 11.4.0 → 11.4.1

package/Server/API/AIAgentTaskAPI.ts

@@ -16,7 +16,6 @@ import { JSONObject } from "../../Types/JSON";
 import ObjectID from "../../Types/ObjectID";
 import OneUptimeDate from "../../Types/Date";
 import AIAgentTaskStatus from "../../Types/AI/AIAgentTaskStatus";
-import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import PositiveNumber from "../../Types/PositiveNumber";
 
 export default class AIAgentTaskAPI extends BaseAPI<
@@ -27,8 +26,10 @@ export default class AIAgentTaskAPI extends BaseAPI<
     super(AIAgentTask, AIAgentTaskService);
 
     /*
-     * Get the next pending (scheduled) task for processing
-     * Validates aiAgentId and aiAgentKey before returning task
+     * Claim the next pending (scheduled) task for processing.
+     * Validates aiAgentId and aiAgentKey before claiming. The task is
+     * atomically transitioned Scheduled -> InProgress before it is
+     * returned, so concurrent workers can never receive the same task.
      */
     this.router.post(
       `${new this.entityType().getCrudApiPath()?.toString()}/get-pending-task`,
@@ -39,7 +40,7 @@ export default class AIAgentTaskAPI extends BaseAPI<
           /* Validate AI Agent credentials */
           const aiAgent: AIAgent | null = await this.validateAIAgent(data);
 
-          if (!aiAgent) {
+          if (!aiAgent || !aiAgent.id) {
             return Response.sendErrorResponse(
               req,
               res,
@@ -47,25 +48,10 @@ export default class AIAgentTaskAPI extends BaseAPI<
             );
           }
 
-          /* Fetch one scheduled task, sorted by createdAt (oldest first) */
-          const task: AIAgentTask | null = await AIAgentTaskService.findOneBy({
-            query: {
-              status: AIAgentTaskStatus.Scheduled,
-            },
-            sort: {
-              createdAt: SortOrder.Ascending,
-            },
-            select: {
-              _id: true,
-              projectId: true,
-              taskType: true,
-              metadata: true,
-              createdAt: true,
-            },
-            props: {
-              isRoot: true,
-            },
-          });
+          const task: AIAgentTask | null =
+            await AIAgentTaskService.claimNextScheduledTask({
+              aiAgentId: aiAgent.id,
+            });
 
           if (!task) {
             return Response.sendJsonObjectResponse(req, res, {
@@ -82,7 +68,7 @@ export default class AIAgentTaskAPI extends BaseAPI<
               metadata: task.metadata as JSONObject | undefined,
               createdAt: task.createdAt,
             },
-            message: "Task fetched successfully",
+            message: "Task claimed successfully",
           });
         } catch (err) {
           next(err);

package/Server/API/TelemetryAPI.ts

@@ -404,9 +404,10 @@ router.post(
         ? (body["spanIds"] as Array<string>)
         : undefined;
 
-      const attributes: Record<string, string> | undefined = body["attributes"]
-        ? (body["attributes"] as Record<string, string>)
-        : undefined;
+      const attributes: Record<string, string | Array<string>> | undefined =
+        body["attributes"]
+          ? (body["attributes"] as Record<string, string | Array<string>>)
+          : undefined;
 
       const request: HistogramRequest = {
         projectId: databaseProps.tenantId,

package/Server/Services/AIAgentTaskService.ts

@@ -11,6 +11,7 @@ import Semaphore, { SemaphoreMutex } from "../Infrastructure/Semaphore";
 import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import logger from "../Utils/Logger";
 import OneUptimeDate from "../../Types/Date";
+import AIAgentTaskStatus from "../../Types/AI/AIAgentTaskStatus";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -80,6 +81,67 @@ export class Service extends DatabaseService<Model> {
     return { createBy, carryForward: null };
   }
 
+  /*
+   * Atomically claim the oldest Scheduled task for a worker: the
+   * Scheduled -> InProgress transition is guarded on status, so when
+   * multiple workers poll concurrently only one claim succeeds
+   * (updateOneBy returns the number of rows changed — zero means another
+   * worker won the race, so we retry with the next candidate). The
+   * returned task is already InProgress and owned by the given agent.
+   */
+  @CaptureSpan()
+  public async claimNextScheduledTask(data: {
+    aiAgentId: ObjectID;
+  }): Promise<Model | null> {
+    const maxClaimAttempts: number = 5;
+
+    for (let attempt: number = 0; attempt < maxClaimAttempts; attempt++) {
+      const task: Model | null = await this.findOneBy({
+        query: {
+          status: AIAgentTaskStatus.Scheduled,
+        },
+        sort: {
+          createdAt: SortOrder.Ascending,
+        },
+        select: {
+          _id: true,
+          projectId: true,
+          taskType: true,
+          metadata: true,
+          createdAt: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (!task || !task.id) {
+        return null;
+      }
+
+      const claimedCount: number = await this.updateOneBy({
+        query: {
+          _id: task.id.toString(),
+          status: AIAgentTaskStatus.Scheduled,
+        },
+        data: {
+          status: AIAgentTaskStatus.InProgress,
+          aiAgentId: data.aiAgentId,
+          startedAt: OneUptimeDate.getCurrentDate(),
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (claimedCount > 0) {
+        return task;
+      }
+    }
+
+    return null;
+  }
+
   @CaptureSpan()
   public async getExistingTaskNumberForProject(data: {
     projectId: ObjectID;

package/Server/Services/AnalyticsDatabaseService.ts

@@ -813,6 +813,19 @@ export default class AnalyticsDatabaseService<
         ? Object.keys(aggregateBy.groupBy)
         : [];
 
+      /*
+       * Attribute-key grouping returns the selected keys folded into a
+       * single `attributes` map column (see MetricService); carry it
+       * onto the aggregated rows so series splitters can read labels.
+       */
+      if (
+        aggregateBy.groupByAttributeKeys &&
+        aggregateBy.groupByAttributeKeys.length > 0 &&
+        !groupByColumnNames.includes("attributes")
+      ) {
+        groupByColumnNames.push("attributes");
+      }
+
       for (const item of items) {
         if (
           !(item as JSONObject)[
@@ -1171,6 +1184,20 @@ export default class AnalyticsDatabaseService<
     statement: Statement;
     columns: Array<string>;
   } {
+    /*
+     * Attribute-key grouping needs model-specific SQL over a map column
+     * (MetricService builds it); reaching this generic path with keys
+     * set would silently return ungrouped results.
+     */
+    if (
+      aggregateBy.groupByAttributeKeys &&
+      aggregateBy.groupByAttributeKeys.length > 0
+    ) {
+      throw new BadDataException(
+        `groupByAttributeKeys is not supported for ${this.model.tableName}.`,
+      );
+    }
+
     if (!this.database) {
       this.useDefaultDatabase();
     }

package/Server/Services/LogAggregationService.ts

@@ -17,6 +17,9 @@ export interface HistogramBucket {
   count: number;
 }
 
+export type LogAttributeFilterValue = string | Array<string>;
+export type LogAttributeFilters = Record<string, LogAttributeFilterValue>;
+
 export interface HistogramRequest {
   projectId: ObjectID;
   startTime: Date;
@@ -28,7 +31,7 @@ export interface HistogramRequest {
   bodySearchText?: string | undefined;
   traceIds?: Array<string> | undefined;
   spanIds?: Array<string> | undefined;
-  attributes?: Record<string, string> | undefined;
+  attributes?: LogAttributeFilters | undefined;
 }
 
 export interface FacetValue {
@@ -49,7 +52,7 @@ export interface FacetRequest {
   bodySearchText?: string | undefined;
   traceIds?: Array<string> | undefined;
   spanIds?: Array<string> | undefined;
-  attributes?: Record<string, string> | undefined;
+  attributes?: LogAttributeFilters | undefined;
 }
 
 export type AnalyticsChartType = "timeseries" | "toplist" | "table";
@@ -834,15 +837,30 @@ export class LogAggregationService {
          * remember the exact casing is a poor experience. The user-supplied
          * key is validated above.
          */
-        statement.append(
-          SQL` AND arrayExists((k, v) -> lowerUTF8(k) = lowerUTF8(${{
-            type: TableColumnType.Text,
-            value: attrKey,
-          }}) AND v = ${{
-            type: TableColumnType.Text,
-            value: attrValue,
-          }}, mapKeys(attributes), mapValues(attributes))`,
-        );
+        if (Array.isArray(attrValue)) {
+          if (attrValue.length === 0) {
+            continue;
+          }
+          statement.append(
+            SQL` AND arrayExists((k, v) -> lowerUTF8(k) = lowerUTF8(${{
+              type: TableColumnType.Text,
+              value: attrKey,
+            }}) AND v IN (${{
+              type: TableColumnType.Text,
+              value: new Includes(attrValue),
+            }}), mapKeys(attributes), mapValues(attributes))`,
+          );
+        } else {
+          statement.append(
+            SQL` AND arrayExists((k, v) -> lowerUTF8(k) = lowerUTF8(${{
+              type: TableColumnType.Text,
+              value: attrKey,
+            }}) AND v = ${{
+              type: TableColumnType.Text,
+              value: attrValue,
+            }}, mapKeys(attributes), mapValues(attributes))`,
+          );
+        }
       }
     }
   }