142 lines
3.9 KiB
TypeScript
142 lines
3.9 KiB
TypeScript
import Logger from "@server/logging/Logger";
|
|
import { setResource } from "@server/logging/tracer";
|
|
import { traceFunction } from "@server/logging/tracing";
|
|
import { initI18n } from "@server/utils/i18n";
|
|
import {
|
|
globalEventQueue,
|
|
processorEventQueue,
|
|
websocketQueue,
|
|
taskQueue,
|
|
} from "../queues";
|
|
import processors from "../queues/processors";
|
|
import tasks from "../queues/tasks";
|
|
|
|
export default function init() {
|
|
initI18n();
|
|
|
|
// This queue processes the global event bus
|
|
globalEventQueue.process(
|
|
traceFunction({
|
|
serviceName: "worker",
|
|
spanName: "process",
|
|
isRoot: true,
|
|
})(async function (job) {
|
|
const event = job.data;
|
|
let err;
|
|
|
|
setResource(`Event.${event.name}`);
|
|
|
|
Logger.info("worker", `Processing ${event.name}`, {
|
|
name: event.name,
|
|
modelId: event.modelId,
|
|
attempt: job.attemptsMade,
|
|
});
|
|
|
|
// For each registered processor we check to see if it wants to handle the
|
|
// event (applicableEvents), and if so add a new queued job specifically
|
|
// for that processor.
|
|
for (const name in processors) {
|
|
const ProcessorClass = processors[name];
|
|
|
|
if (!ProcessorClass) {
|
|
throw new Error(
|
|
`Received event "${event.name}" for processor (${name}) that isn't registered. Check the file name matches the class name.`
|
|
);
|
|
}
|
|
|
|
try {
|
|
if (name === "WebsocketsProcessor") {
|
|
// websockets are a special case on their own queue because they must
|
|
// only be consumed by the websockets service rather than workers.
|
|
await websocketQueue.add(job.data);
|
|
} else if (
|
|
ProcessorClass.applicableEvents.includes(event.name) ||
|
|
ProcessorClass.applicableEvents.includes("*")
|
|
) {
|
|
await processorEventQueue.add({ event, name });
|
|
}
|
|
} catch (error) {
|
|
Logger.error(
|
|
`Error adding ${event.name} to ${name} queue`,
|
|
error,
|
|
event
|
|
);
|
|
err = error;
|
|
}
|
|
}
|
|
|
|
if (err) {
|
|
throw err;
|
|
}
|
|
})
|
|
);
|
|
|
|
// Jobs for individual processors are processed here. Only applicable events
|
|
// as unapplicable events were filtered in the global event queue above.
|
|
processorEventQueue.process(
|
|
traceFunction({
|
|
serviceName: "worker",
|
|
spanName: "process",
|
|
isRoot: true,
|
|
})(async function (job) {
|
|
const { event, name } = job.data;
|
|
const ProcessorClass = processors[name];
|
|
|
|
setResource(`Processor.${name}`);
|
|
|
|
if (!ProcessorClass) {
|
|
throw new Error(
|
|
`Received event "${event.name}" for processor (${name}) that isn't registered. Check the file name matches the class name.`
|
|
);
|
|
}
|
|
|
|
const processor = new ProcessorClass();
|
|
|
|
if (processor.perform) {
|
|
Logger.info("worker", `${name} running ${event.name}`, {
|
|
name: event.name,
|
|
modelId: event.modelId,
|
|
});
|
|
|
|
try {
|
|
await processor.perform(event);
|
|
} catch (err) {
|
|
Logger.error(`Error processing ${event.name} in ${name}`, err, event);
|
|
throw err;
|
|
}
|
|
}
|
|
})
|
|
);
|
|
|
|
// Jobs for async tasks are processed here.
|
|
taskQueue.process(
|
|
traceFunction({
|
|
serviceName: "worker",
|
|
spanName: "process",
|
|
isRoot: true,
|
|
})(async function (job) {
|
|
const { name, props } = job.data;
|
|
const TaskClass = tasks[name];
|
|
|
|
setResource(`Task.${name}`);
|
|
|
|
if (!TaskClass) {
|
|
throw new Error(
|
|
`Task "${name}" is not registered. Check the file name matches the class name.`
|
|
);
|
|
}
|
|
|
|
Logger.info("worker", `${name} running`, props);
|
|
|
|
const task = new TaskClass();
|
|
|
|
try {
|
|
await task.perform(props);
|
|
} catch (err) {
|
|
Logger.error(`Error processing task in ${name}`, err, props);
|
|
throw err;
|
|
}
|
|
})
|
|
);
|
|
}
|