Skip to content

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

6.3 KB
Raw Blame
import { isNil, tryCatch } from '@activepieces/core-utils'
import { ApEdition, ExecutioOutputFile, FileCompression, FileType, FlowRunStatus, isFlowRunStateTerminal, logSerializer, RunInternalError, RunInternalErrorSource, SendFlowResponseRequest, StreamStepProgress, truncateFailedStepMessage, UpdateStepProgressRequest, UploadRunLogsRequest, WebsocketClientEvent } from '@activepieces/shared'
import { FastifyBaseLogger } from 'fastify'
import { StatusCodes } from 'http-status-codes'
import { websocketService } from '../../core/websockets.service'
import { fileCompressor } from '../../file/file-compressor'
import { fileService } from '../../file/file.service'
import { pubsub } from '../../helper/pubsub'
import { system } from '../../helper/system/system'
import { projectService } from '../../project/project-service'
import { RunsMetadataUpsertData } from '../../workers/job'
import { runsMetadataQueue } from './flow-runs-queue'

export const engineRunCallbackService = (log: FastifyBaseLogger) => ({
    updateRunProgress({ projectId, request }: UpdateRunProgressParams): void {
        websocketService.to(projectId).emit(WebsocketClientEvent.UPDATE_RUN_PROGRESS, request)
    },

    updateStepProgress({ projectId, request }: UpdateStepProgressParams): void {
        websocketService.to(projectId).emit(WebsocketClientEvent.TEST_STEP_PROGRESS, request)
    },

    async sendFlowResponse({ request }: SendFlowResponseParams): Promise<void> {
        await pubsub.publish(
            `engine-run:sync:${request.workerHandlerId}`,
            JSON.stringify({ requestId: request.httpRequestId, response: request.runResponse }),
        )
    },

    async uploadRunLog({ projectId, request }: UploadRunLogParams): Promise<void> {
        const internalErrorEnabled = request.internalError?.source === RunInternalErrorSource.ENGINE || system.getEdition() !== ApEdition.CLOUD
        const internalError = internalErrorEnabled ? request.internalError : undefined
        const isTerminal = !isNil(request.status) && isFlowRunStateTerminal({ status: request.status, ignoreInternalError: false })
        if (isTerminal && !isNil(request.logsFileId)) {
            await ensureLogsFileExists({
                log,
                projectId,
                logsFileId: request.logsFileId,
                internalError,
            })
        }
        const logData: RunsMetadataUpsertData = {
            id: request.runId,
            projectId,
            status: request.status,
            tags: request.tags,
            logsFileId: request.logsFileId,
            failedStep: truncateFailedStepMessage(request.failedStep),
            startTime: request.startTime,
            finishTime: request.finishTime,
            stepsCount: request.stepsCount,
            stepNameToTest: request.stepNameToTest,
            provisionMs: request.provisionMs,
            bootMs: request.bootMs,
            runMs: request.runMs,
            willRetry: request.willRetry,
        }
        await runsMetadataQueue(log).add(logData)

        if (!isNil(request.status) && FAILED_RUN_SYNC_STATUSES.includes(request.status) && !isNil(request.workerHandlerId) && !isNil(request.httpRequestId)) {
            await engineRunCallbackService(log).sendFlowResponse({
                request: {
                    workerHandlerId: request.workerHandlerId,
                    httpRequestId: request.httpRequestId,
                    runResponse: {
                        status: StatusCodes.INTERNAL_SERVER_ERROR,
                        body: { message: FAILED_RUN_SYNC_MESSAGE },
                        headers: {},
                    },
                },
            })
        }

        if (request.stepResponse && request.streamStepProgress === StreamStepProgress.WEBSOCKET) {
            const stepData = { ...request.stepResponse, projectId }
            if (!isTerminal) {
                websocketService.to(projectId).emit(WebsocketClientEvent.TEST_STEP_PROGRESS, stepData)
            }
            else {
                websocketService.to(projectId).emit(WebsocketClientEvent.TEST_STEP_FINISHED, stepData)
            }
        }
    },
})

const FAILED_RUN_SYNC_STATUSES = [
    FlowRunStatus.FAILED,
    FlowRunStatus.INTERNAL_ERROR,
    FlowRunStatus.TIMEOUT,
    FlowRunStatus.MEMORY_LIMIT_EXCEEDED,
    FlowRunStatus.LOG_SIZE_EXCEEDED,
]
const FAILED_RUN_SYNC_MESSAGE = 'The flow has failed and there is no response returned'

async function ensureLogsFileExists({ log, projectId, logsFileId, internalError }: EnsureLogsFileParams): Promise<void> {
    const { error } = await tryCatch(async () => {
        const fileExists = await fileService(log).exists({
            projectId,
            fileId: logsFileId,
            type: FileType.FLOW_RUN_LOG,
        })
        if (fileExists && isNil(internalError)) {
            return
        }

        const existing = fileExists
            ? await fileService(log).getDataOrUndefined({ projectId, fileId: logsFileId, type: FileType.FLOW_RUN_LOG })
            : undefined
        const outputFile: ExecutioOutputFile = !isNil(existing)
            ? JSON.parse(existing.data.toString('utf-8'))
            : { executionState: { steps: {}, tags: [] } }

        const data = await fileCompressor.compress({
            data: await logSerializer.serialize(isNil(internalError) ? outputFile : { ...outputFile, internalError }),
            compression: FileCompression.ZSTD,
        })

        const platformId = await projectService(log).getPlatformId(projectId)
        await fileService(log).save({
            fileId: logsFileId,
            projectId,
            platformId,
            type: FileType.FLOW_RUN_LOG,
            data,
            size: data.length,
            compression: FileCompression.ZSTD,
        })
    })

    if (error) {
        log.error({ error, logsFileId, project: { id: projectId } }, '[uploadRunLog] Failed to ensure logs file exists')
    }
}

type UpdateRunProgressParams = {
    projectId: string
    request: unknown
}

type UpdateStepProgressParams = {
    projectId: string
    request: UpdateStepProgressRequest
}

type SendFlowResponseParams = {
    request: SendFlowResponseRequest
}

type UploadRunLogParams = {
    projectId: string
    request: UploadRunLogsRequest
}

type EnsureLogsFileParams = {
    log: FastifyBaseLogger
    projectId: string
    logsFileId: string
    internalError?: RunInternalError
}