Merge branch 'master' into elu-strategy

[poolifier.git] / src / worker / abstract-worker.ts

diff --git a/src/worker/abstract-worker.ts b/src/worker/abstract-worker.ts
index a7060770be39e70a73a9a8327d9d4f99bc1582c5..a484dce12927c1cd29721e9529aa08a822c37b43 100644 (file)
--- a/src/worker/abstract-worker.ts
+++ b/src/worker/abstract-worker.ts
@@ -1,6 +1,7 @@
 import { AsyncResource } from 'node:async_hooks'
 import type { Worker } from 'node:cluster'
 import type { MessagePort } from 'node:worker_threads'
+import { type EventLoopUtilization, performance } from 'node:perf_hooks'
 import type {
   MessageValue,
   TaskFunctions,
@@ -9,13 +10,23 @@ import type {
   WorkerSyncFunction
 } from '../utility-types'
 import { EMPTY_FUNCTION, isPlainObject } from '../utils'
-import type { KillBehavior, WorkerOptions } from './worker-options'
-import { KillBehaviors } from './worker-options'
+import {
+  type KillBehavior,
+  KillBehaviors,
+  type WorkerOptions
+} from './worker-options'
 
 const DEFAULT_FUNCTION_NAME = 'default'
 const DEFAULT_MAX_INACTIVE_TIME = 60000
 const DEFAULT_KILL_BEHAVIOR: KillBehavior = KillBehaviors.SOFT
 
+interface TaskPerformance {
+  timestamp: number
+  waitTime: number
+  runTime?: number
+  elu: EventLoopUtilization
+}
+
 /**
  * Base class that implements some shared logic for all poolifier workers.
  *
@@ -87,6 +98,7 @@ export abstract class AbstractWorker<
     this.opts.killBehavior = opts.killBehavior ?? DEFAULT_KILL_BEHAVIOR
     this.opts.maxInactiveTime =
       opts.maxInactiveTime ?? DEFAULT_MAX_INACTIVE_TIME
+    delete this.opts.async
   }
 
   /**
@@ -205,17 +217,23 @@ export abstract class AbstractWorker<
     message: MessageValue<Data>
   ): void {
     try {
-      const startTimestamp = performance.now()
+      const taskPerformance = this.beforeTaskRunHook(message)
       const res = fn(message.data)
-      const runTime = performance.now() - startTimestamp
+      const { runTime, waitTime, elu } = this.afterTaskRunHook(taskPerformance)
       this.sendToMainWorker({
         data: res,
-        id: message.id,
-        runTime
+        runTime,
+        waitTime,
+        elu,
+        id: message.id
       })
     } catch (e) {
       const err = this.handleError(e as Error)
-      this.sendToMainWorker({ error: err, id: message.id })
+      this.sendToMainWorker({
+        error: err,
+        errorData: message.data,
+        id: message.id
+      })
     } finally {
       !this.isMain && (this.lastTaskTimestamp = performance.now())
     }
@@ -231,20 +249,27 @@ export abstract class AbstractWorker<
     fn: WorkerAsyncFunction<Data, Response>,
     message: MessageValue<Data>
   ): void {
-    const startTimestamp = performance.now()
+    const taskPerformance = this.beforeTaskRunHook(message)
     fn(message.data)
       .then(res => {
-        const runTime = performance.now() - startTimestamp
+        const { runTime, waitTime, elu } =
+          this.afterTaskRunHook(taskPerformance)
         this.sendToMainWorker({
           data: res,
-          id: message.id,
-          runTime
+          runTime,
+          waitTime,
+          elu,
+          id: message.id
         })
         return null
       })
       .catch(e => {
         const err = this.handleError(e as Error)
-        this.sendToMainWorker({ error: err, id: message.id })
+        this.sendToMainWorker({
+          error: err,
+          errorData: message.data,
+          id: message.id
+        })
       })
       .finally(() => {
         !this.isMain && (this.lastTaskTimestamp = performance.now())
@@ -261,8 +286,28 @@ export abstract class AbstractWorker<
     name = name ?? DEFAULT_FUNCTION_NAME
     const fn = this.taskFunctions.get(name)
     if (fn == null) {
-      throw new Error(`Task function "${name}" not found`)
+      throw new Error(`Task function '${name}' not found`)
     }
     return fn
   }
+
+  private beforeTaskRunHook (message: MessageValue<Data>): TaskPerformance {
+    // TODO: conditional accounting
+    const timestamp = performance.now()
+    return {
+      timestamp,
+      waitTime: timestamp - (message.submissionTimestamp ?? 0),
+      elu: performance.eventLoopUtilization()
+    }
+  }
+
+  private afterTaskRunHook (taskPerformance: TaskPerformance): TaskPerformance {
+    return {
+      ...taskPerformance,
+      ...{
+        runTime: performance.now() - taskPerformance.timestamp,
+        elu: performance.eventLoopUtilization(taskPerformance.elu)
+      }
+    }
+  }
 }