@twin.org/dataspace-data-plane-service 0.0.3-next.25 → 0.0.3-next.26

package/dist/es/dataspaceDataPlaneService.js

@@ -4,7 +4,7 @@ import { ArrayHelper, BaseError, ComponentFactory, ConflictError, Converter, Gen
 import { Blake2b } from "@twin.org/crypto";
 import { DataTypeHelper, JsonSchemaHelper } from "@twin.org/data-core";
 import { JsonLdDataTypes, JsonLdHelper, JsonLdProcessor } from "@twin.org/data-json-ld";
-import { ActivityProcessingStatus, DataRequestType, DataspaceAppFactory, DataspaceContexts, DataspaceDataTypes, DataspaceTypes } from "@twin.org/dataspace-models";
+import { ActivityProcessingStatus, ActivityTaskStatus, DataRequestType, DataspaceAppFactory, DataspaceContexts, DataspaceDataTypes, DataspaceTypes } from "@twin.org/dataspace-models";
 import { EngineCoreFactory } from "@twin.org/engine-models";
 import { ComparisonOperator, LogicalOperator } from "@twin.org/entity";
 import { EntityStorageConnectorFactory } from "@twin.org/entity-storage-models";
@@ -70,6 +70,11 @@ export class DataspaceDataPlaneService {
      * @internal
      */
     _activityLogStatusCallbacks;
+    /**
+     * Track task handler registrations to avoid resetting worker pools on every task.
+     * @internal
+     */
+    _registeredTaskTypes;
     /**
      * Task retention. -1 retain forever.
      * @internal
@@ -80,6 +85,11 @@ export class DataspaceDataPlaneService {
      * @internal
      */
     _retainActivityLogsFor;
+    /**
+     * Retry count for failed tasks.
+     * @internal
+     */
+    _retryCount;
     /**
      * Clean up interval for activity logs.
      * @internal
@@ -144,11 +154,13 @@ export class DataspaceDataPlaneService {
         DataspaceProtocolDataTypes.registerRedirects();
         DataspaceProtocolDataTypes.registerTypes();
         this._activityLogStatusCallbacks = {};
+        this._registeredTaskTypes = [];
         this._partitionContextIds = options?.partitionContextIds;
         this._retainTasksFor =
             DataspaceDataPlaneService._DEFAULT_RETAIN_INTERVAL * DataspaceDataPlaneService._MS_PER_MINUTE;
         this._retainActivityLogsFor =
             DataspaceDataPlaneService._DEFAULT_RETAIN_INTERVAL * DataspaceDataPlaneService._MS_PER_MINUTE;
+        this._retryCount = options?.config?.retryCount;
         this._activityLogCleanUpInterval = DataspaceDataPlaneService._DEFAULT_CLEANUP_INTERVAL;
         this._cleanUpProcessOngoing = false;
         const validationErrors = [];
@@ -225,7 +237,7 @@ export class DataspaceDataPlaneService {
     /**
      * Notify an Activity.
      * @param activity The Activity notified.
-     * @returns The Activity's Log Entry identifier.
+     * @returns The activity's id or entry.
      */
     async notifyActivity(activity) {
         Guards.object(DataspaceDataPlaneService.CLASS_NAME, "activity", activity);
@@ -255,10 +267,11 @@ export class DataspaceDataPlaneService {
         const activityLogId = Converter.bytesToHex(Blake2b.sum256(canonicalBytes));
         const activityLogEntryId = `urn:x-activity-log:${activityLogId}`;
         // Check if entry already exists
-        const existingLogEntry = await this._entityStorageActivityLogs.get(activityLogEntryId);
+        let logEntry = await this._entityStorageActivityLogs.get(activityLogEntryId);
         let existingSuccessfulApps = [];
         let isRetry = false;
-        if (!Is.undefined(existingLogEntry)) {
+        const now = Date.now();
+        if (!Is.undefined(logEntry)) {
             // Check if there are failed tasks that can be retried
             const existingEntry = await this.getActivityLogEntry(activityLogEntryId);
             // If all tasks completed successfully, this is a duplicate
@@ -276,69 +289,46 @@ export class DataspaceDataPlaneService {
             isRetry = true;
         }
         else {
-            const logEntry = {
+            logEntry = {
                 id: activityLogEntryId,
-                activityId: Is.string(activity.id) ? activity.id : undefined,
+                activityId: activity.id,
                 generator: this.calculateActivityGeneratorIdentity(activity),
-                dateCreated: new Date().toISOString(),
-                dateModified: new Date().toISOString()
+                dateCreated: new Date(now).toISOString(),
+                dateModified: new Date(now).toISOString()
             };
             await this._entityStorageActivityLogs.set(logEntry);
         }
         const activityQuerySet = await this.calculateActivityQuerySet(activity);
-        const tasksScheduled = [];
-        const dataspaceAppIds = [];
+        const taskEntries = [];
+        const handlerApps = {};
         for (const query of activityQuerySet) {
-            const appIds = this.getAppForActivityQuery(query);
-            for (const appId of appIds) {
-                if (!dataspaceAppIds.includes(appId)) {
-                    dataspaceAppIds.push(appId);
+            const apps = this.getAppForActivityQuery(query);
+            for (const appId in apps) {
+                // Only process apps that haven't already completed successfully
+                if (!handlerApps[appId] && !existingSuccessfulApps.includes(appId)) {
+                    handlerApps[appId] = apps[appId];
                 }
             }
         }
-        for (const dataspaceAppId of dataspaceAppIds) {
-            // Only process apps that haven't already completed successfully
-            if (!existingSuccessfulApps.includes(dataspaceAppId)) {
-                const payload = {
-                    activityLogEntryId,
-                    activity: activity,
-                    executorApp: dataspaceAppId
-                };
-                const taskType = Converter.bytesToHex(RandomHelper.generate(16));
-                const taskId = await this._backgroundTaskComponent.create(taskType, payload, {
-                    retainFor: this._retainTasksFor
-                });
-                await this._backgroundTaskComponent.registerHandler(taskType, "@twin.org/dataspace-app-runner", "appRunner", async (task) => {
-                    await this.finaliseTask(task);
-                }, {
-                    initialiseMethod: "appRunnerStart",
-                    shutdownMethod: "appRunnerEnd"
-                });
-                tasksScheduled.push({
-                    taskId,
-                    dataspaceAppId
-                });
-                await this._logging?.log({
-                    level: "info",
-                    source: DataspaceDataPlaneService.CLASS_NAME,
-                    message: "scheduledTask",
-                    data: {
-                        taskId,
-                        dataspaceAppId,
-                        isRetry
-                    }
-                });
+        let inlineCount = 0;
+        for (const handlerAppId in handlerApps) {
+            if (await this.processTask(activityLogEntryId, activity, handlerApps, handlerAppId, taskEntries, isRetry)) {
+                inlineCount++;
             }
         }
         const existingActivityTasks = isRetry
             ? await this._entityStorageActivityTasks.get(activityLogEntryId)
             : undefined;
         const existingTasksToKeep = existingActivityTasks?.associatedTasks.filter(t => existingSuccessfulApps.includes(t.dataspaceAppId)) ?? [];
-        await this._entityStorageActivityTasks.set({
+        const activityTask = {
             activityLogEntryId,
-            associatedTasks: [...existingTasksToKeep, ...tasksScheduled]
-        });
-        return activityLogEntryId;
+            associatedTasks: [...existingTasksToKeep, ...taskEntries]
+        };
+        await this._entityStorageActivityTasks.set(activityTask);
+        if (inlineCount === taskEntries.length) {
+            return this.finaliseActivityLogEntry(activityLogEntryId);
+        }
+        return activityTask.activityLogEntryId;
     }
     /**
      * Subscribes to the activity log.
@@ -370,68 +360,12 @@ export class DataspaceDataPlaneService {
      */
     async getActivityLogEntry(logEntryId) {
         Guards.stringValue(DataspaceDataPlaneService.CLASS_NAME, "logEntryId", logEntryId);
-        const result = await this._entityStorageActivityLogs.get(logEntryId);
-        if (Is.undefined(result)) {
+        const activityLog = await this._entityStorageActivityLogs.get(logEntryId);
+        if (Is.undefined(activityLog)) {
             throw new NotFoundError(DataspaceDataPlaneService.CLASS_NAME, "activityLogEntryNotFound", logEntryId);
         }
-        let pendingTasks;
-        let runningTasks;
-        let finalizedTasks;
-        let inErrorTasks;
-        // For calculating the processing status. `Registering` if we cannot determine the activity tasks yet
-        let status = ActivityProcessingStatus.Registering;
-        // Now query the associated tasks
         const activityTasks = await this._entityStorageActivityTasks.get(logEntryId);
-        // If activity tasks is undefined it is because the corresponding store has not been persisted yet
-        if (!Is.undefined(activityTasks)) {
-            pendingTasks = [];
-            runningTasks = [];
-            finalizedTasks = [];
-            inErrorTasks = [];
-            for (const entity of activityTasks.associatedTasks) {
-                const taskDetails = await this._backgroundTaskComponent.get(entity.taskId);
-                if (Is.object(taskDetails)) {
-                    switch (taskDetails.status) {
-                        case TaskStatus.Success:
-                            finalizedTasks.push({
-                                ...entity,
-                                result: JSON.stringify(taskDetails.result),
-                                startDate: taskDetails?.dateCreated,
-                                endDate: taskDetails?.dateCompleted
-                            });
-                            break;
-                        case TaskStatus.Pending:
-                            pendingTasks.push(entity);
-                            break;
-                        case TaskStatus.Processing:
-                            runningTasks.push({ ...entity, startDate: taskDetails.dateCreated });
-                            break;
-                        case TaskStatus.Failed:
-                            inErrorTasks.push({
-                                ...entity,
-                                error: taskDetails.error
-                            });
-                            break;
-                        case TaskStatus.Cancelled:
-                            // Nothing to do for cancelled tasks
-                            break;
-                    }
-                }
-            }
-            if (Is.arrayValue(inErrorTasks)) {
-                status = ActivityProcessingStatus.Error;
-            }
-            else if (Is.arrayValue(runningTasks)) {
-                status = ActivityProcessingStatus.Running;
-            }
-            else if (Is.arrayValue(pendingTasks)) {
-                status = ActivityProcessingStatus.Pending;
-            }
-            else {
-                status = ActivityProcessingStatus.Completed;
-            }
-        }
-        return { ...result, status, pendingTasks, runningTasks, finalizedTasks, inErrorTasks };
+        return this.constructLogEntry(activityLog, activityTasks);
     }
     /**
      * Get Data Asset entities. Allows to retrieve entities by their type or id.
@@ -471,9 +405,7 @@ export class DataspaceDataPlaneService {
         }
         const datasetId = serviceDataset["@id"];
         Guards.stringValue(DataspaceDataPlaneService.CLASS_NAME, "datasetId", datasetId);
-        const appId = await this.getAppForDataAssetQuery({ datasetId });
-        // getAppForDataAssetQuery already validates app exists
-        const app = DataspaceAppFactory.get(appId);
+        const app = await this.getAppForDataAssetQuery({ datasetId });
         const handleDataRequest = app.handleDataRequest?.bind(app);
         Guards.function(DataspaceDataPlaneService.CLASS_NAME, "handleDataRequest", handleDataRequest);
         const dataRequest = {
@@ -537,8 +469,7 @@ export class DataspaceDataPlaneService {
         const serviceDataset = await this.getDatasetFromApps(resolvedDatasetId);
         const datasetId = serviceDataset["@id"];
         Guards.stringValue(DataspaceDataPlaneService.CLASS_NAME, "datasetId", datasetId);
-        const appId = await this.getAppForDataAssetQuery({ datasetId });
-        const app = DataspaceAppFactory.get(appId);
+        const app = await this.getAppForDataAssetQuery({ datasetId });
         if (!app.supportedQueryTypes().includes(query.type)) {
             throw new UnprocessableError(DataspaceDataPlaneService.CLASS_NAME, "queryTypeNotSupported", {
                 queryType: query.type
@@ -643,55 +574,65 @@ export class DataspaceDataPlaneService {
     }
     /**
      * Process activity task finalization.
-     * @param proofEntity The proof entity to process.
+     * @param taskId The Id of the Activity Log Entry.
+     * @param status The final status of the task.
+     * @param payload The execution payload of the task, required to correlate to the Activity Log Entry and update the processing status.
      * @internal
      */
-    async finaliseTask(task) {
-        const payload = task.payload;
+    async finaliseBackgroundTask(taskId, status, payload) {
         if (Is.empty(payload)) {
             return;
         }
-        const activityLogEntry = await this._entityStorageActivityLogs.get(payload.activityLogEntryId);
-        if (Is.undefined(activityLogEntry)) {
-            await this._logging?.log({
-                level: "error",
-                source: DataspaceDataPlaneService.CLASS_NAME,
-                message: "unknownActivityLogEntryId",
-                data: {
-                    activityLogEntryId: payload.activityLogEntryId
+        if (status === TaskStatus.Success || status === TaskStatus.Failed) {
+            await this.notifyTaskStatusChanged(payload.activityLogEntryId, payload.activity.id, payload.dataspaceAppId, taskId, status);
+            await this.finaliseActivityLogEntry(payload.activityLogEntryId);
+        }
+    }
+    /**
+     * Notify registered callbacks about a task status change.
+     * @param activityLogEntryId The Id of the Activity Log Entry.
+     * @param activityId The Id of the Activity.
+     * @param dataspaceAppId The Id of the Dataspace App associated with the task.
+     * @param taskId The Id of the task.
+     * @param taskStatus The new status of the task.
+     * @internal
+     */
+    async notifyTaskStatusChanged(activityLogEntryId, activityId, dataspaceAppId, taskId, taskStatus) {
+        for (const callback of Object.values(this._activityLogStatusCallbacks)) {
+            await callback({
+                activityLogEntryId,
+                activityId,
+                taskProcessingStatus: {
+                    dataspaceAppId,
+                    taskId,
+                    taskStatus
                 }
             });
         }
-        if (task.status === TaskStatus.Success || task.status === TaskStatus.Failed) {
-            for (const callback of Object.values(this._activityLogStatusCallbacks)) {
-                await callback({
-                    activityLogEntryId: payload.activityLogEntryId,
-                    activityId: Is.string(payload.activity.id) ? payload.activity.id : undefined,
-                    taskProcessingStatus: {
-                        dataspaceAppId: payload.executorApp,
-                        taskId: task.id,
-                        taskStatus: task.status
-                    }
-                });
-            }
-            // Now let's see if the full activity processing has completed, if so the entry must be marked for retention
-            if (this._retainActivityLogsFor !== -1) {
-                const entry = await this.getActivityLogEntry(payload.activityLogEntryId);
-                if (entry.status === ActivityProcessingStatus.Completed ||
-                    entry.status === ActivityProcessingStatus.Error) {
-                    const retainUntil = Date.now() + this._retainActivityLogsFor;
-                    await this._entityStorageActivityLogs.set({
-                        id: entry.id,
-                        activityId: entry.activityId,
-                        generator: entry.generator,
-                        dateCreated: entry.dateCreated,
-                        dateModified: entry.dateModified,
-                        retainUntil,
-                        retryCount: entry.retryCount
-                    });
-                }
-            }
+    }
+    /**
+     * Finalizes the Activity Log Entry by checking if all associated tasks have completed and, if so, updating the entry to be retained for the configured retention period.
+     * @param activityLogEntryId The Id of the Activity Log Entry to finalize.
+     * @returns The Activity Log Entry with updated retention details if applicable.
+     * @internal
+     */
+    async finaliseActivityLogEntry(activityLogEntryId) {
+        const entry = await this.getActivityLogEntry(activityLogEntryId);
+        if (this._retainActivityLogsFor !== -1 &&
+            (entry.status === ActivityProcessingStatus.Completed ||
+                entry.status === ActivityProcessingStatus.Error)) {
+            const retainUntil = Date.now() + this._retainActivityLogsFor;
+            const updatedEntry = {
+                id: entry.id,
+                activityId: entry.activityId,
+                generator: entry.generator,
+                dateCreated: entry.dateCreated,
+                dateModified: entry.dateModified,
+                retainUntil
+            };
+            await this._entityStorageActivityLogs.set(updatedEntry);
         }
+        return entry;
     }
     /**
      * Cleans up the activity log by deleting those entries that no longer shall be retained.
@@ -850,7 +791,7 @@ export class DataspaceDataPlaneService {
      * @internal
      */
     getAppForActivityQuery(activityQuery) {
-        const matchingElements = [];
+        const matchingElements = {};
         const appNames = DataspaceAppFactory.names();
         for (const appId of appNames) {
             const app = DataspaceAppFactory.get(appId);
@@ -860,10 +801,10 @@ export class DataspaceDataPlaneService {
                     (Is.undefined(appQuery.activityType) ||
                         appQuery.activityType === activityQuery.activityType) &&
                     (Is.undefined(appQuery.targetType) || appQuery.targetType === activityQuery.targetType)) {
-                    // Avoid duplicates. Only one DS App can be executed per activity
-                    if (!matchingElements.includes(appId)) {
-                        matchingElements.push(appId);
-                    }
+                    matchingElements[appId] = {
+                        app,
+                        processingGroupId: appQuery.processingGroupId
+                    };
                 }
             }
         }
@@ -899,18 +840,20 @@ export class DataspaceDataPlaneService {
      */
     async getAppForDataAssetQuery(dataAssetQuery) {
         const matchingElements = [];
+        const matchingIds = [];
         const appNames = DataspaceAppFactory.names();
         for (const appId of appNames) {
             const app = DataspaceAppFactory.get(appId);
             const datasets = await app.datasetsHandled();
             for (const dataset of datasets) {
                 if (dataset["@id"] === dataAssetQuery.datasetId) {
-                    matchingElements.push(appId);
+                    matchingElements.push(app);
+                    matchingIds.push(appId);
                 }
             }
         }
         if (matchingElements.length > 1) {
-            const error = new ConflictError(DataspaceDataPlaneService.CLASS_NAME, "tooManyAppsRegistered", dataAssetQuery.datasetId, matchingElements, {
+            const error = new ConflictError(DataspaceDataPlaneService.CLASS_NAME, "tooManyAppsRegistered", dataAssetQuery.datasetId, matchingIds, {
                 datasetId: dataAssetQuery.datasetId
             });
             await this._logging?.log({
@@ -949,11 +892,15 @@ export class DataspaceDataPlaneService {
      * @internal
      */
     async prepareForRetry(activityLogEntryId, existingEntry) {
-        const appsToRetry = existingEntry.inErrorTasks?.map(t => t.dataspaceAppId) ?? [];
+        const appsToRetry = existingEntry.tasks
+            ?.filter(t => t.status === ActivityTaskStatus.Failed)
+            .map(t => t.dataspaceAppId) ?? [];
         if (!Is.arrayValue(appsToRetry)) {
             throw new NotFoundError(DataspaceDataPlaneService.CLASS_NAME, "noFailedTasksToRetry", activityLogEntryId);
         }
-        const successfulApps = existingEntry.finalizedTasks?.map(t => t.dataspaceAppId) ?? [];
+        const successfulApps = existingEntry.tasks
+            ?.filter(t => t.status === ActivityTaskStatus.Success)
+            .map(t => t.dataspaceAppId) ?? [];
         await this._logging?.log({
             level: "debug",
             source: DataspaceDataPlaneService.CLASS_NAME,
@@ -971,8 +918,6 @@ export class DataspaceDataPlaneService {
             if (this._retainActivityLogsFor !== -1) {
                 logEntry.retainUntil = Date.now() + this._retainActivityLogsFor;
             }
-            // Monitoring purposes
-            logEntry.retryCount = (logEntry.retryCount ?? 0) + 1;
             await this._entityStorageActivityLogs.set(logEntry);
         }
         return successfulApps;
@@ -1068,5 +1013,183 @@ export class DataspaceDataPlaneService {
             });
         }
     }
+    /**
+     * Processes a task for an activity, by creating a background task and registering the handler.
+     * @param activityLogEntryId The ID of the activity log entry.
+     * @param activity The activity to be processed.
+     * @param handlerApps The handler applications for the activity.
+     * @param dataspaceAppId The ID of the handler application.
+     * @param taskEntries The list of activity log entries.
+     * @param isRetry Indicates if this is a retry of a previous task.
+     * @returns True if the task was processed inline.
+     * @internal
+     */
+    async processTask(activityLogEntryId, activity, handlerApps, dataspaceAppId, taskEntries, isRetry) {
+        const handlerApp = handlerApps[dataspaceAppId].app;
+        const processingGroupId = handlerApps[dataspaceAppId].processingGroupId;
+        const payload = {
+            activityLogEntryId,
+            activity: activity,
+            dataspaceAppId
+        };
+        // If there is no processing group we execute the task inline without creating a background task
+        const isInlineTask = !Is.stringValue(processingGroupId);
+        if (isInlineTask) {
+            const handleActivity = handlerApp?.handleActivity?.bind(handlerApp);
+            if (!Is.function(handleActivity)) {
+                throw new GeneralError(DataspaceDataPlaneService.CLASS_NAME, "missingHandleActivity", {
+                    dataspaceAppId
+                });
+            }
+            let taskError;
+            let taskResult;
+            try {
+                taskResult = await handleActivity(activity);
+            }
+            catch (error) {
+                taskError = BaseError.fromError(error);
+            }
+            const now = Date.now();
+            const taskEntry = {
+                taskId: RandomHelper.generateUuidV7("compact"),
+                dataspaceAppId,
+                processingGroupId,
+                result: taskResult,
+                startDate: new Date(now).toISOString(),
+                endDate: new Date(now).toISOString(),
+                status: Is.empty(taskError) ? ActivityTaskStatus.Success : ActivityTaskStatus.Failed,
+                error: taskError
+            };
+            taskEntries.push(taskEntry);
+            await this.notifyTaskStatusChanged(payload.activityLogEntryId, payload.activity.id, payload.dataspaceAppId, taskEntry.taskId, taskEntry.status);
+        }
+        else {
+            const processingGroups = handlerApp.processingGroups?.() ?? {};
+            if (Is.empty(processingGroups[processingGroupId])) {
+                throw new GeneralError(DataspaceDataPlaneService.CLASS_NAME, "invalidProcessingGroupId", {
+                    processingGroupId
+                });
+            }
+            const processingGroupOptions = processingGroups[processingGroupId];
+            const taskType = `${dataspaceAppId}${processingGroupId ? `-${processingGroupId}` : ""}`;
+            const taskId = await this._backgroundTaskComponent.create(taskType, payload, {
+                retainFor: this._retainTasksFor,
+                retryCount: processingGroupOptions?.retryCount ?? this._retryCount
+            });
+            if (!this._registeredTaskTypes.includes(taskType)) {
+                this._registeredTaskTypes.push(taskType);
+                await this._backgroundTaskComponent.registerHandler(taskType, "@twin.org/dataspace-app-runner", "appRunner", async (task) => {
+                    await this.finaliseBackgroundTask(task.id, task.status, task.payload);
+                }, {
+                    maxWorkerCount: processingGroupOptions?.concurrentTasks,
+                    idleShutdownTimeout: processingGroupOptions?.idleShutdownTimeout,
+                    initialiseMethod: "appRunnerStart",
+                    shutdownMethod: "appRunnerEnd"
+                });
+            }
+            taskEntries.push({
+                taskId,
+                dataspaceAppId,
+                processingGroupId,
+                status: ActivityTaskStatus.Pending
+            });
+            await this._logging?.log({
+                level: "info",
+                source: DataspaceDataPlaneService.CLASS_NAME,
+                message: "scheduledTask",
+                data: {
+                    taskId,
+                    dataspaceAppId,
+                    isRetry
+                }
+            });
+        }
+        return isInlineTask;
+    }
+    /**
+     * Constructs the activity log entry with processing status and associated tasks.
+     * @param activityLog The activity log details retrieved from storage.
+     * @param activityTasks The activity tasks associated with the log entry, if any.
+     * @returns The complete activity log entry with status and tasks.
+     * @internal
+     */
+    async constructLogEntry(activityLog, activityTasks) {
+        let tasks;
+        // For calculating the processing status. `Registering` if we cannot determine the activity tasks yet
+        let status = ActivityProcessingStatus.Registering;
+        // Now query the associated tasks
+        // If activity tasks is undefined it is because the corresponding store has not been persisted yet
+        if (!Is.undefined(activityTasks)) {
+            tasks = [];
+            const typeCount = {
+                [TaskStatus.Pending]: 0,
+                [TaskStatus.Processing]: 0,
+                [TaskStatus.Success]: 0,
+                [TaskStatus.Failed]: 0,
+                [TaskStatus.Cancelled]: 0
+            };
+            for (const entity of activityTasks.associatedTasks) {
+                let entry;
+                if (!Is.stringValue(entity.processingGroupId)) {
+                    // If there is no process group, the task was processed inline so the task status is already available in the entity
+                    typeCount[entity.status]++;
+                    entry = entity;
+                }
+                else {
+                    const taskDetails = await this._backgroundTaskComponent.get(entity.taskId);
+                    if (!Is.empty(taskDetails)) {
+                        typeCount[taskDetails.status]++;
+                        switch (taskDetails.status) {
+                            case TaskStatus.Success:
+                                entry = {
+                                    ...entity,
+                                    status: ActivityTaskStatus.Success,
+                                    result: taskDetails.result,
+                                    startDate: taskDetails?.dateCreated,
+                                    endDate: taskDetails?.dateCompleted
+                                };
+                                break;
+                            case TaskStatus.Pending:
+                                entry = { ...entity, status: ActivityTaskStatus.Pending };
+                                break;
+                            case TaskStatus.Processing:
+                                entry = {
+                                    ...entity,
+                                    status: ActivityTaskStatus.Processing,
+                                    startDate: taskDetails.dateCreated
+                                };
+                                break;
+                            case TaskStatus.Failed:
+                                entry = {
+                                    ...entity,
+                                    status: ActivityTaskStatus.Failed,
+                                    error: taskDetails.error
+                                };
+                                break;
+                            case TaskStatus.Cancelled:
+                                // Nothing to do for cancelled tasks
+                                break;
+                        }
+                    }
+                }
+                if (!Is.empty(entry)) {
+                    tasks.push(entry);
+                }
+            }
+            if (typeCount[TaskStatus.Failed] > 0) {
+                status = ActivityProcessingStatus.Error;
+            }
+            else if (typeCount[TaskStatus.Processing] > 0) {
+                status = ActivityProcessingStatus.Running;
+            }
+            else if (typeCount[TaskStatus.Pending] > 0) {
+                status = ActivityProcessingStatus.Pending;
+            }
+            else {
+                status = ActivityProcessingStatus.Completed;
+            }
+        }
+        return { ...activityLog, status, tasks };
+    }
 }
 //# sourceMappingURL=dataspaceDataPlaneService.js.map