Files
triggerdotdev--trigger.dev/apps/webapp/app/v3/services/updateFatalRunError.server.ts
nicktrn d2c779eb0f Fixes for internal error reattempts (#1436)
* magic links on span event errors

* prevent task monitor from processing errors handled elsewhere

* exclusively use internal error code enum for completion data

* add complete attempt service opts

* reattempts need to go via the queue for task controllers that may have exited

* only infer retry config if completed via crash or system failure

* enhance error before deciding if retriable

* retry on SIGTERM

* enable retry config helper for latest sdk

* don't retry heartbeat timeouts for now

* enable task monitor to update fatal errors

* add missing service

* update retry config since package version

* don't alter completion time when updating existing error
2024-10-28 19:15:47 +00:00

58 lines
1.6 KiB
TypeScript

import { BaseService } from "./baseService.server";
import { logger } from "~/services/logger.server";
import { isFatalRunStatus } from "../taskStatus";
import { TaskRunErrorCodes, TaskRunInternalError } from "@trigger.dev/core/v3";
import { FinalizeTaskRunService } from "./finalizeTaskRun.server";
export type UpdateFatalRunErrorServiceOptions = {
reason?: string;
exitCode?: number;
logs?: string;
errorCode?: TaskRunInternalError["code"];
};
export class UpdateFatalRunErrorService extends BaseService {
public async call(runId: string, options?: UpdateFatalRunErrorServiceOptions) {
const opts = {
reason: "Worker crashed",
...options,
};
logger.debug("UpdateFatalRunErrorService.call", { runId, opts });
const taskRun = await this._prisma.taskRun.findFirst({
where: {
id: runId,
},
});
if (!taskRun) {
logger.error("[UpdateFatalRunErrorService] Task run not found", { runId });
return;
}
if (!isFatalRunStatus(taskRun.status)) {
logger.warn("[UpdateFatalRunErrorService] Task run is not in a fatal state", {
runId,
status: taskRun.status,
});
return;
}
logger.debug("[UpdateFatalRunErrorService] Updating crash error", { runId, options });
const finalizeService = new FinalizeTaskRunService();
await finalizeService.call({
id: taskRun.id,
status: "CRASHED",
error: {
type: "INTERNAL_ERROR",
code: opts.errorCode ?? TaskRunErrorCodes.TASK_RUN_CRASHED,
message: opts.reason,
stackTrace: opts.logs,
},
});
}
}