---
[poolifier.git] / src / worker / abstract-worker.ts
CommitLineData
6677a3d3 1import type { Worker } from 'node:cluster'
d715b7bc 2import { performance } from 'node:perf_hooks'
ded253e2
JB
3import type { MessagePort } from 'node:worker_threads'
4
d715b7bc
JB
5import type {
6 MessageValue,
5c4d16da 7 Task,
31847469 8 TaskFunctionProperties,
d715b7bc
JB
9 TaskPerformance,
10 WorkerStatistics
d35e5717 11} from '../utility-types.js'
ff128cc9 12import {
31847469 13 buildTaskFunctionProperties,
ff128cc9
JB
14 DEFAULT_TASK_NAME,
15 EMPTY_FUNCTION,
16 isAsyncFunction,
17 isPlainObject
d35e5717 18} from '../utils.js'
b6b32453 19import type {
82ea6492
JB
20 TaskAsyncFunction,
21 TaskFunction,
31847469 22 TaskFunctionObject,
4e38fd21 23 TaskFunctionOperationResult,
b6b32453 24 TaskFunctions,
82ea6492 25 TaskSyncFunction
d35e5717 26} from './task-functions.js'
9a38f99e
JB
27import {
28 checkTaskFunctionName,
bcfb06ce 29 checkValidTaskFunctionObjectEntry,
9a38f99e 30 checkValidWorkerOptions
d35e5717 31} from './utils.js'
ded253e2 32import { KillBehaviors, type WorkerOptions } from './worker-options.js'
4c35177b 33
978aad6f 34const DEFAULT_MAX_INACTIVE_TIME = 60000
d38d0e30
JB
35const DEFAULT_WORKER_OPTIONS: WorkerOptions = {
36 /**
37 * The kill behavior option on this worker or its default value.
38 */
39 killBehavior: KillBehaviors.SOFT,
40 /**
41 * The maximum time to keep this worker active while idle.
42 * The pool automatically checks and terminates this worker when the time expires.
43 */
44 maxInactiveTime: DEFAULT_MAX_INACTIVE_TIME,
45 /**
46 * The function to call when the worker is killed.
47 */
48 killHandler: EMPTY_FUNCTION
49}
c97c7edb 50
729c563d 51/**
ea7a90d3 52 * Base class that implements some shared logic for all poolifier workers.
729c563d 53 *
38e795c1 54 * @typeParam MainWorker - Type of main worker.
e102732c
JB
55 * @typeParam Data - Type of data this worker receives from pool's execution. This can only be structured-cloneable data.
56 * @typeParam Response - Type of response the worker sends back to the main worker. This can only be structured-cloneable data.
729c563d 57 */
c97c7edb 58export abstract class AbstractWorker<
6677a3d3 59 MainWorker extends Worker | MessagePort,
d3c8a1a8
S
60 Data = unknown,
61 Response = unknown
69b70a7e 62> {
f59e1027 63 /**
83fa0a36 64 * Worker id.
f59e1027
JB
65 */
66 protected abstract id: number
a86b6df1 67 /**
31847469 68 * Task function object(s) processed by the worker when the pool's `execution` function is invoked.
a86b6df1 69 */
31847469 70 protected taskFunctions!: Map<string, TaskFunctionObject<Data, Response>>
729c563d
S
71 /**
72 * Timestamp of the last task processed by this worker.
73 */
a9d9ea34 74 protected lastTaskTimestamp!: number
b6b32453 75 /**
8a970421 76 * Performance statistics computation requirements.
b6b32453 77 */
c63a35a0 78 protected statistics?: WorkerStatistics
729c563d 79 /**
b0a4db63 80 * Handler id of the `activeInterval` worker activity check.
729c563d 81 */
b0a4db63 82 protected activeInterval?: NodeJS.Timeout
49890030 83
c97c7edb 84 /**
729c563d 85 * Constructs a new poolifier worker.
c97c7edb 86 *
38e795c1 87 * @param isMain - Whether this is the main worker or not.
38e795c1 88 * @param mainWorker - Reference to main worker.
85aeb3f3 89 * @param taskFunctions - Task function(s) processed by the worker when the pool's `execution` function is invoked. The first function is the default function.
38e795c1 90 * @param opts - Options for the worker.
c97c7edb
S
91 */
92 public constructor (
c63a35a0
JB
93 protected readonly isMain: boolean | undefined,
94 private readonly mainWorker: MainWorker | undefined | null,
82ea6492 95 taskFunctions: TaskFunction<Data, Response> | TaskFunctions<Data, Response>,
d38d0e30 96 protected opts: WorkerOptions = DEFAULT_WORKER_OPTIONS
c97c7edb 97 ) {
9d2d0da1
JB
98 if (this.isMain == null) {
99 throw new Error('isMain parameter is mandatory')
100 }
a86b6df1 101 this.checkTaskFunctions(taskFunctions)
9d2d0da1 102 this.checkWorkerOptions(this.opts)
1f68cede 103 if (!this.isMain) {
0cb6edc2 104 // Should be once() but Node.js on windows has a bug that prevents it from working
e2898b4f 105 this.getMainWorker().on('message', this.handleReadyMessage.bind(this))
c97c7edb
S
106 }
107 }
108
41aa7dcd 109 private checkWorkerOptions (opts: WorkerOptions): void {
9a38f99e 110 checkValidWorkerOptions(opts)
d38d0e30 111 this.opts = { ...DEFAULT_WORKER_OPTIONS, ...opts }
41aa7dcd
JB
112 }
113
114 /**
c20084b6 115 * Checks if the `taskFunctions` parameter is passed to the constructor and valid.
41aa7dcd 116 *
82888165 117 * @param taskFunctions - The task function(s) parameter that should be checked.
41aa7dcd 118 */
a86b6df1 119 private checkTaskFunctions (
c63a35a0
JB
120 taskFunctions:
121 | TaskFunction<Data, Response>
122 | TaskFunctions<Data, Response>
123 | undefined
a86b6df1 124 ): void {
ec8fd331
JB
125 if (taskFunctions == null) {
126 throw new Error('taskFunctions parameter is mandatory')
127 }
31847469 128 this.taskFunctions = new Map<string, TaskFunctionObject<Data, Response>>()
0d80593b 129 if (typeof taskFunctions === 'function') {
31847469
JB
130 const fnObj = { taskFunction: taskFunctions.bind(this) }
131 this.taskFunctions.set(DEFAULT_TASK_NAME, fnObj)
2a69b8c5
JB
132 this.taskFunctions.set(
133 typeof taskFunctions.name === 'string' &&
efebef40 134 taskFunctions.name.trim().length > 0
2a69b8c5
JB
135 ? taskFunctions.name
136 : 'fn1',
31847469 137 fnObj
2a69b8c5 138 )
0d80593b 139 } else if (isPlainObject(taskFunctions)) {
82888165 140 let firstEntry = true
31847469
JB
141 for (let [name, fnObj] of Object.entries(taskFunctions)) {
142 if (typeof fnObj === 'function') {
143 fnObj = { taskFunction: fnObj } satisfies TaskFunctionObject<
144 Data,
145 Response
146 >
147 }
bcfb06ce 148 checkValidTaskFunctionObjectEntry<Data, Response>(name, fnObj)
31847469 149 fnObj.taskFunction = fnObj.taskFunction.bind(this)
82888165 150 if (firstEntry) {
31847469 151 this.taskFunctions.set(DEFAULT_TASK_NAME, fnObj)
82888165
JB
152 firstEntry = false
153 }
31847469 154 this.taskFunctions.set(name, fnObj)
a86b6df1 155 }
630f0acf
JB
156 if (firstEntry) {
157 throw new Error('taskFunctions parameter object is empty')
158 }
a86b6df1 159 } else {
f34fdabe
JB
160 throw new TypeError(
161 'taskFunctions parameter is not a function or a plain object'
162 )
41aa7dcd
JB
163 }
164 }
165
968a2e8c
JB
166 /**
167 * Checks if the worker has a task function with the given name.
168 *
169 * @param name - The name of the task function to check.
170 * @returns Whether the worker has a task function with the given name or not.
968a2e8c 171 */
4e38fd21 172 public hasTaskFunction (name: string): TaskFunctionOperationResult {
6703b9f4 173 try {
9a38f99e 174 checkTaskFunctionName(name)
6703b9f4
JB
175 } catch (error) {
176 return { status: false, error: error as Error }
177 }
178 return { status: this.taskFunctions.has(name) }
968a2e8c
JB
179 }
180
181 /**
182 * Adds a task function to the worker.
183 * If a task function with the same name already exists, it is replaced.
184 *
185 * @param name - The name of the task function to add.
186 * @param fn - The task function to add.
187 * @returns Whether the task function was added or not.
968a2e8c
JB
188 */
189 public addTaskFunction (
190 name: string,
31847469 191 fn: TaskFunction<Data, Response> | TaskFunctionObject<Data, Response>
4e38fd21 192 ): TaskFunctionOperationResult {
968a2e8c 193 try {
9a38f99e 194 checkTaskFunctionName(name)
6703b9f4
JB
195 if (name === DEFAULT_TASK_NAME) {
196 throw new Error(
197 'Cannot add a task function with the default reserved name'
198 )
199 }
31847469
JB
200 if (typeof fn === 'function') {
201 fn = { taskFunction: fn } satisfies TaskFunctionObject<Data, Response>
6703b9f4 202 }
bcfb06ce 203 checkValidTaskFunctionObjectEntry<Data, Response>(name, fn)
31847469 204 fn.taskFunction = fn.taskFunction.bind(this)
968a2e8c
JB
205 if (
206 this.taskFunctions.get(name) ===
207 this.taskFunctions.get(DEFAULT_TASK_NAME)
208 ) {
31847469 209 this.taskFunctions.set(DEFAULT_TASK_NAME, fn)
968a2e8c 210 }
31847469
JB
211 this.taskFunctions.set(name, fn)
212 this.sendTaskFunctionsPropertiesToMainWorker()
6703b9f4
JB
213 return { status: true }
214 } catch (error) {
215 return { status: false, error: error as Error }
968a2e8c
JB
216 }
217 }
218
219 /**
220 * Removes a task function from the worker.
221 *
222 * @param name - The name of the task function to remove.
223 * @returns Whether the task function existed and was removed or not.
968a2e8c 224 */
4e38fd21 225 public removeTaskFunction (name: string): TaskFunctionOperationResult {
6703b9f4 226 try {
9a38f99e 227 checkTaskFunctionName(name)
6703b9f4
JB
228 if (name === DEFAULT_TASK_NAME) {
229 throw new Error(
230 'Cannot remove the task function with the default reserved name'
231 )
232 }
233 if (
234 this.taskFunctions.get(name) ===
235 this.taskFunctions.get(DEFAULT_TASK_NAME)
236 ) {
237 throw new Error(
238 'Cannot remove the task function used as the default task function'
239 )
240 }
241 const deleteStatus = this.taskFunctions.delete(name)
31847469 242 this.sendTaskFunctionsPropertiesToMainWorker()
6703b9f4
JB
243 return { status: deleteStatus }
244 } catch (error) {
245 return { status: false, error: error as Error }
968a2e8c 246 }
968a2e8c
JB
247 }
248
249 /**
31847469 250 * Lists the properties of the worker's task functions.
c50b93fb 251 *
31847469 252 * @returns The properties of the worker's task functions.
c50b93fb 253 */
31847469 254 public listTaskFunctionsProperties (): TaskFunctionProperties[] {
d8a4de75 255 let defaultTaskFunctionName = DEFAULT_TASK_NAME
31847469 256 for (const [name, fnObj] of this.taskFunctions) {
b558f6b5
JB
257 if (
258 name !== DEFAULT_TASK_NAME &&
31847469 259 fnObj === this.taskFunctions.get(DEFAULT_TASK_NAME)
b558f6b5
JB
260 ) {
261 defaultTaskFunctionName = name
262 break
263 }
264 }
31847469
JB
265 const taskFunctionsProperties: TaskFunctionProperties[] = []
266 for (const [name, fnObj] of this.taskFunctions) {
267 if (name === DEFAULT_TASK_NAME || name === defaultTaskFunctionName) {
268 continue
269 }
270 taskFunctionsProperties.push(buildTaskFunctionProperties(name, fnObj))
271 }
b558f6b5 272 return [
31847469
JB
273 buildTaskFunctionProperties(
274 DEFAULT_TASK_NAME,
275 this.taskFunctions.get(DEFAULT_TASK_NAME)
276 ),
277 buildTaskFunctionProperties(
278 defaultTaskFunctionName,
279 this.taskFunctions.get(defaultTaskFunctionName)
280 ),
281 ...taskFunctionsProperties
b558f6b5 282 ]
c50b93fb
JB
283 }
284
285 /**
286 * Sets the default task function to use in the worker.
968a2e8c
JB
287 *
288 * @param name - The name of the task function to use as default task function.
289 * @returns Whether the default task function was set or not.
968a2e8c 290 */
4e38fd21 291 public setDefaultTaskFunction (name: string): TaskFunctionOperationResult {
968a2e8c 292 try {
9a38f99e 293 checkTaskFunctionName(name)
6703b9f4
JB
294 if (name === DEFAULT_TASK_NAME) {
295 throw new Error(
296 'Cannot set the default task function reserved name as the default task function'
297 )
298 }
299 if (!this.taskFunctions.has(name)) {
300 throw new Error(
301 'Cannot set the default task function to a non-existing task function'
302 )
303 }
67f3f2d6
JB
304 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
305 this.taskFunctions.set(DEFAULT_TASK_NAME, this.taskFunctions.get(name)!)
31847469 306 this.sendTaskFunctionsPropertiesToMainWorker()
6703b9f4
JB
307 return { status: true }
308 } catch (error) {
309 return { status: false, error: error as Error }
968a2e8c
JB
310 }
311 }
312
a038b517
JB
313 /**
314 * Handles the ready message sent by the main worker.
315 *
316 * @param message - The ready message.
317 */
318 protected abstract handleReadyMessage (message: MessageValue<Data>): void
319
aee46736
JB
320 /**
321 * Worker message listener.
322 *
6b813701 323 * @param message - The received message.
aee46736 324 */
85aeb3f3 325 protected messageListener (message: MessageValue<Data>): void {
9e746eec 326 this.checkMessageWorkerId(message)
43805f1d
JB
327 const {
328 statistics,
329 checkActive,
330 taskFunctionOperation,
331 taskId,
332 data,
333 kill
334 } = message
335 if (statistics != null) {
310de0aa 336 // Statistics message received
43805f1d
JB
337 this.statistics = statistics
338 } else if (checkActive != null) {
310de0aa 339 // Check active message received
43805f1d
JB
340 checkActive ? this.startCheckActive() : this.stopCheckActive()
341 } else if (taskFunctionOperation != null) {
6703b9f4
JB
342 // Task function operation message received
343 this.handleTaskFunctionOperationMessage(message)
43805f1d 344 } else if (taskId != null && data != null) {
310de0aa
JB
345 // Task message received
346 this.run(message)
43805f1d 347 } else if (kill === true) {
310de0aa
JB
348 // Kill message received
349 this.handleKillMessage(message)
cf597bc5
JB
350 }
351 }
352
6703b9f4
JB
353 protected handleTaskFunctionOperationMessage (
354 message: MessageValue<Data>
355 ): void {
31847469
JB
356 const { taskFunctionOperation, taskFunctionProperties, taskFunction } =
357 message
358 if (taskFunctionProperties == null) {
7f0e1334 359 throw new Error(
31847469 360 'Cannot handle task function operation message without task function properties'
7f0e1334
JB
361 )
362 }
363 let response: TaskFunctionOperationResult
d2dd5ef5
JB
364 switch (taskFunctionOperation) {
365 case 'add':
31847469 366 response = this.addTaskFunction(taskFunctionProperties.name, {
7f0e1334 367 // eslint-disable-next-line @typescript-eslint/no-implied-eval, no-new-func
31847469
JB
368 taskFunction: new Function(
369 `return ${taskFunction}`
370 )() as TaskFunction<Data, Response>,
371 ...(taskFunctionProperties.priority != null && {
372 priority: taskFunctionProperties.priority
373 }),
374 ...(taskFunctionProperties.strategy != null && {
375 strategy: taskFunctionProperties.strategy
376 })
377 })
d2dd5ef5
JB
378 break
379 case 'remove':
31847469 380 response = this.removeTaskFunction(taskFunctionProperties.name)
d2dd5ef5
JB
381 break
382 case 'default':
31847469 383 response = this.setDefaultTaskFunction(taskFunctionProperties.name)
d2dd5ef5
JB
384 break
385 default:
386 response = { status: false, error: new Error('Unknown task operation') }
387 break
6703b9f4
JB
388 }
389 this.sendToMainWorker({
390 taskFunctionOperation,
391 taskFunctionOperationStatus: response.status,
31847469 392 taskFunctionProperties,
adee6053 393 ...(!response.status &&
c63a35a0 394 response.error != null && {
adee6053 395 workerError: {
31847469 396 name: taskFunctionProperties.name,
adee6053
JB
397 message: this.handleError(response.error as Error | string)
398 }
399 })
6703b9f4
JB
400 })
401 }
402
984dc9c8
JB
403 /**
404 * Handles a kill message sent by the main worker.
405 *
406 * @param message - The kill message.
407 */
97cf8c0d 408 protected handleKillMessage (_message: MessageValue<Data>): void {
29d8b961 409 this.stopCheckActive()
07588f30 410 if (isAsyncFunction(this.opts.killHandler)) {
c63a35a0 411 (this.opts.killHandler() as Promise<void>)
1e3214b6 412 .then(() => {
895b5341 413 this.sendToMainWorker({ kill: 'success' })
fefd3cef 414 return undefined
1e3214b6
JB
415 })
416 .catch(() => {
895b5341 417 this.sendToMainWorker({ kill: 'failure' })
1e3214b6 418 })
07588f30 419 } else {
1e3214b6
JB
420 try {
421 // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
422 this.opts.killHandler?.() as void
895b5341 423 this.sendToMainWorker({ kill: 'success' })
7c8ac84e 424 } catch {
895b5341 425 this.sendToMainWorker({ kill: 'failure' })
1e3214b6 426 }
07588f30 427 }
984dc9c8
JB
428 }
429
9e746eec
JB
430 /**
431 * Check if the message worker id is set and matches the worker id.
432 *
433 * @param message - The message to check.
434 * @throws {@link https://nodejs.org/api/errors.html#class-error} If the message worker id is not set or does not match the worker id.
435 */
436 private checkMessageWorkerId (message: MessageValue<Data>): void {
437 if (message.workerId == null) {
438 throw new Error('Message worker id is not set')
8e5a7cf9 439 } else if (message.workerId !== this.id) {
9e746eec
JB
440 throw new Error(
441 `Message worker id ${message.workerId} does not match the worker id ${this.id}`
442 )
443 }
444 }
445
48487131 446 /**
b0a4db63 447 * Starts the worker check active interval.
48487131 448 */
b0a4db63 449 private startCheckActive (): void {
75d3401a 450 this.lastTaskTimestamp = performance.now()
b0a4db63
JB
451 this.activeInterval = setInterval(
452 this.checkActive.bind(this),
75d3401a 453 (this.opts.maxInactiveTime ?? DEFAULT_MAX_INACTIVE_TIME) / 2
984dc9c8 454 )
75d3401a
JB
455 }
456
48487131 457 /**
b0a4db63 458 * Stops the worker check active interval.
48487131 459 */
b0a4db63 460 private stopCheckActive (): void {
c3f498b5
JB
461 if (this.activeInterval != null) {
462 clearInterval(this.activeInterval)
463 delete this.activeInterval
464 }
48487131
JB
465 }
466
467 /**
468 * Checks if the worker should be terminated, because its living too long.
469 */
b0a4db63 470 private checkActive (): void {
48487131
JB
471 if (
472 performance.now() - this.lastTaskTimestamp >
473 (this.opts.maxInactiveTime ?? DEFAULT_MAX_INACTIVE_TIME)
474 ) {
895b5341 475 this.sendToMainWorker({ kill: this.opts.killBehavior })
48487131
JB
476 }
477 }
478
729c563d
S
479 /**
480 * Returns the main worker.
838898f1
S
481 *
482 * @returns Reference to the main worker.
155bb3de 483 * @throws {@link https://nodejs.org/api/errors.html#class-error} If the main worker is not set.
729c563d 484 */
838898f1 485 protected getMainWorker (): MainWorker {
78cea37e 486 if (this.mainWorker == null) {
e102732c 487 throw new Error('Main worker not set')
838898f1
S
488 }
489 return this.mainWorker
490 }
c97c7edb 491
729c563d 492 /**
aa9eede8 493 * Sends a message to main worker.
729c563d 494 *
38e795c1 495 * @param message - The response message.
729c563d 496 */
82f36766
JB
497 protected abstract sendToMainWorker (
498 message: MessageValue<Response, Data>
499 ): void
c97c7edb 500
90d7d101 501 /**
31847469 502 * Sends task functions properties to the main worker.
90d7d101 503 */
31847469 504 protected sendTaskFunctionsPropertiesToMainWorker (): void {
90d7d101 505 this.sendToMainWorker({
31847469 506 taskFunctionsProperties: this.listTaskFunctionsProperties()
90d7d101
JB
507 })
508 }
509
729c563d 510 /**
8accb8d5 511 * Handles an error and convert it to a string so it can be sent back to the main worker.
729c563d 512 *
6703b9f4 513 * @param error - The error raised by the worker.
ab80dc46 514 * @returns The error message.
729c563d 515 */
6703b9f4
JB
516 protected handleError (error: Error | string): string {
517 return error instanceof Error ? error.message : error
c97c7edb
S
518 }
519
5c4d16da
JB
520 /**
521 * Runs the given task.
522 *
523 * @param task - The task to execute.
5c4d16da 524 */
803f948f 525 protected readonly run = (task: Task<Data>): void => {
9d2d0da1 526 const { name, taskId, data } = task
c878a240
JB
527 const taskFunctionName = name ?? DEFAULT_TASK_NAME
528 if (!this.taskFunctions.has(taskFunctionName)) {
9d2d0da1 529 this.sendToMainWorker({
6703b9f4 530 workerError: {
67f3f2d6
JB
531 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
532 name: name!,
c63a35a0 533 message: `Task function '${name}' not found`,
9d2d0da1
JB
534 data
535 },
9d2d0da1
JB
536 taskId
537 })
538 return
539 }
31847469 540 const fn = this.taskFunctions.get(taskFunctionName)?.taskFunction
5c4d16da 541 if (isAsyncFunction(fn)) {
69b70a7e 542 this.runAsync(fn as TaskAsyncFunction<Data, Response>, task)
5c4d16da 543 } else {
69b70a7e 544 this.runSync(fn as TaskSyncFunction<Data, Response>, task)
5c4d16da
JB
545 }
546 }
547
729c563d 548 /**
4dd93fcf 549 * Runs the given task function synchronously.
729c563d 550 *
5c4d16da
JB
551 * @param fn - Task function that will be executed.
552 * @param task - Input data for the task function.
729c563d 553 */
803f948f 554 protected readonly runSync = (
82ea6492 555 fn: TaskSyncFunction<Data, Response>,
5c4d16da 556 task: Task<Data>
803f948f 557 ): void => {
310de0aa 558 const { name, taskId, data } = task
c97c7edb 559 try {
310de0aa
JB
560 let taskPerformance = this.beginTaskPerformance(name)
561 const res = fn(data)
d715b7bc 562 taskPerformance = this.endTaskPerformance(taskPerformance)
3fafb1b2
JB
563 this.sendToMainWorker({
564 data: res,
d715b7bc 565 taskPerformance,
310de0aa 566 taskId
3fafb1b2 567 })
6703b9f4 568 } catch (error) {
91ee39ed 569 this.sendToMainWorker({
6703b9f4 570 workerError: {
67f3f2d6
JB
571 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
572 name: name!,
6703b9f4 573 message: this.handleError(error as Error | string),
310de0aa 574 data
82f36766 575 },
310de0aa 576 taskId
91ee39ed 577 })
6e9d10db 578 } finally {
c3f498b5 579 this.updateLastTaskTimestamp()
c97c7edb
S
580 }
581 }
582
729c563d 583 /**
4dd93fcf 584 * Runs the given task function asynchronously.
729c563d 585 *
5c4d16da
JB
586 * @param fn - Task function that will be executed.
587 * @param task - Input data for the task function.
729c563d 588 */
803f948f 589 protected readonly runAsync = (
82ea6492 590 fn: TaskAsyncFunction<Data, Response>,
5c4d16da 591 task: Task<Data>
803f948f 592 ): void => {
310de0aa
JB
593 const { name, taskId, data } = task
594 let taskPerformance = this.beginTaskPerformance(name)
595 fn(data)
041dc05b 596 .then(res => {
d715b7bc 597 taskPerformance = this.endTaskPerformance(taskPerformance)
3fafb1b2
JB
598 this.sendToMainWorker({
599 data: res,
d715b7bc 600 taskPerformance,
310de0aa 601 taskId
3fafb1b2 602 })
04714ef7 603 return undefined
c97c7edb 604 })
07f6f7b1 605 .catch((error: unknown) => {
91ee39ed 606 this.sendToMainWorker({
6703b9f4 607 workerError: {
67f3f2d6
JB
608 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
609 name: name!,
6703b9f4 610 message: this.handleError(error as Error | string),
310de0aa 611 data
82f36766 612 },
310de0aa 613 taskId
91ee39ed 614 })
6e9d10db
JB
615 })
616 .finally(() => {
c3f498b5 617 this.updateLastTaskTimestamp()
c97c7edb 618 })
6e9d10db 619 .catch(EMPTY_FUNCTION)
c97c7edb 620 }
ec8fd331 621
197b4aa5 622 private beginTaskPerformance (name?: string): TaskPerformance {
c63a35a0
JB
623 if (this.statistics == null) {
624 throw new Error('Performance statistics computation requirements not set')
625 }
62c15a68 626 return {
ff128cc9 627 name: name ?? DEFAULT_TASK_NAME,
1c6fe997 628 timestamp: performance.now(),
c63a35a0
JB
629 ...(this.statistics.elu && {
630 elu: performance.eventLoopUtilization()
631 })
62c15a68
JB
632 }
633 }
634
d9d31201
JB
635 private endTaskPerformance (
636 taskPerformance: TaskPerformance
637 ): TaskPerformance {
c63a35a0
JB
638 if (this.statistics == null) {
639 throw new Error('Performance statistics computation requirements not set')
640 }
62c15a68
JB
641 return {
642 ...taskPerformance,
b6b32453
JB
643 ...(this.statistics.runTime && {
644 runTime: performance.now() - taskPerformance.timestamp
645 }),
646 ...(this.statistics.elu && {
62c15a68 647 elu: performance.eventLoopUtilization(taskPerformance.elu)
b6b32453 648 })
62c15a68
JB
649 }
650 }
8a970421 651
c3f498b5 652 private updateLastTaskTimestamp (): void {
29d8b961 653 if (this.activeInterval != null) {
c3f498b5
JB
654 this.lastTaskTimestamp = performance.now()
655 }
656 }
c97c7edb 657}