@platformatic/runtime 2.69.0 → 2.70.1

package/lib/worker/interceptors.js

@@ -164,14 +164,16 @@ async function getDispatcherOpts (undiciConfig) {
 
 function createThreadInterceptor (runtimeConfig) {
   const telemetry = runtimeConfig.telemetry
-  const hooks = telemetry ? createTelemetryThreadInterceptorHooks() : {}
+
+  const telemetryHooks = telemetry ? createTelemetryThreadInterceptorHooks() : {}
+
   const threadDispatcher = wire({
     // Specifying the domain is critical to avoid flooding the DNS
     // with requests for a domain that's never going to exist.
     domain: '.plt.local',
     port: parentPort,
     timeout: runtimeConfig.serviceTimeout,
-    ...hooks
+    ...telemetryHooks,
   })
   return threadDispatcher
 }

package/lib/worker/itc.js

@@ -9,6 +9,7 @@ const { Unpromise } = require('@watchable/unpromise')
 const errors = require('../errors')
 const { updateUndiciInterceptors } = require('./interceptors')
 const { kITC, kId, kServiceId, kWorkerId } = require('./symbols')
+const { MessagingITC } = require('./messaging')
 
 async function safeHandleInITC (worker, fn) {
   try {
@@ -47,8 +48,8 @@ async function safeHandleInITC (worker, fn) {
   }
 }
 
-async function sendViaITC (worker, name, message) {
-  return safeHandleInITC(worker, () => worker[kITC].send(name, message))
+async function sendViaITC (worker, name, message, transferList) {
+  return safeHandleInITC(worker, () => worker[kITC].send(name, message, { transferList }))
 }
 
 async function waitEventFromITC (worker, event) {
@@ -56,6 +57,15 @@ async function waitEventFromITC (worker, event) {
 }
 
 function setupITC (app, service, dispatcher) {
+  const messaging = new MessagingITC(app.appConfig.id, workerData.config)
+
+  Object.assign(globalThis.platformatic ?? {}, {
+    messaging: {
+      handle: messaging.handle.bind(messaging),
+      send: messaging.send.bind(messaging)
+    }
+  })
+
   const itc = new ITC({
     name: app.appConfig.id + '-worker',
     port: parentPort,
@@ -96,6 +106,7 @@ function setupITC (app, service, dispatcher) {
 
         await dispatcher.interceptor.close()
         itc.close()
+        messaging.close()
       },
 
       async build () {
@@ -116,8 +127,10 @@ function setupITC (app, service, dispatcher) {
 
       async updateWorkersCount (data) {
         const { serviceId, workers } = data
-        const w = workerData.config.serviceMap.get(serviceId)
-        if (w) { w.workers = workers }
+        const worker = workerData.config.serviceMap.get(serviceId)
+        if (worker) {
+          worker.workers = workers
+        }
         workerData.serviceConfig.workers = workers
         workerData.worker.count = workers
       },
@@ -195,6 +208,10 @@ function setupITC (app, service, dispatcher) {
         } catch (err) {
           throw new errors.FailedToPerformCustomReadinessCheckError(service.id, err.message)
         }
+      },
+
+      saveMessagingChannel (channel) {
+        messaging.addSource(channel)
       }
     }
   })

package/lib/worker/messaging.js

@@ -0,0 +1,186 @@
+'use strict'
+
+const { withResolvers, executeWithTimeout, kTimeout } = require('@platformatic/utils')
+const { ITC, generateResponse, sanitize } = require('@platformatic/itc')
+const errors = require('../errors')
+const { RoundRobinMap } = require('./round-robin-map')
+const { kWorkersBroadcast, kITC } = require('./symbols')
+
+const kPendingResponses = Symbol('plt.messaging.pendingResponses')
+
+class MessagingITC extends ITC {
+  #timeout
+  #listener
+  #closeResolvers
+  #broadcastChannel
+  #workers
+  #sources
+
+  constructor (id, runtimeConfig) {
+    super({
+      throwOnMissingHandler: true,
+      name: `${id}-messaging`
+    })
+
+    this.#timeout = runtimeConfig.messagingTimeout
+    this.#workers = new RoundRobinMap()
+    this.#sources = new Set()
+
+    // Start listening on the BroadcastChannel for the list of services
+    this.#broadcastChannel = new BroadcastChannel(kWorkersBroadcast)
+    this.#broadcastChannel.onmessage = this.#updateWorkers.bind(this)
+
+    this.listen()
+  }
+
+  _setupListener (listener) {
+    this.#listener = listener
+  }
+
+  handle (message, handler) {
+    if (typeof message === 'object') {
+      for (const [name, fn] of Object.entries(message)) {
+        super.handle(name, fn)
+      }
+    } else {
+      super.handle(message, handler)
+    }
+  }
+
+  async send (service, name, message, options) {
+    // Get the next worker for the service
+    const worker = this.#workers.next(service)
+
+    if (!worker) {
+      throw new errors.MessagingError(service, 'No workers available')
+    }
+
+    if (!worker.channel) {
+      // Use twice the value here as a fallback measure. The target handler in the main thread is forwarding
+      // the request to the worker, using executeWithTimeout with the user set timeout value.
+      const channel = await executeWithTimeout(
+        globalThis[kITC].send('getWorkerMessagingChannel', { service: worker.service, worker: worker.worker }),
+        this.#timeout * 2
+      )
+
+      /* c8 ignore next 3 - Hard to test */
+      if (channel === kTimeout) {
+        throw new errors.MessagingError(service, 'Timeout while waiting for a communication channel.')
+      }
+
+      worker.channel = channel
+      this.#setupChannel(channel)
+
+      channel[kPendingResponses] = new Map()
+      channel.on('close', this.#handlePendingResponse.bind(this, channel))
+    }
+
+    const context = { ...options }
+    context.channel = worker.channel
+    context.service = worker.service
+    context.trackResponse = true
+
+    const response = await executeWithTimeout(super.send(name, message, context), this.#timeout)
+
+    if (response === kTimeout) {
+      throw new errors.MessagingError(service, 'Timeout while waiting for a response.')
+    }
+
+    return response
+  }
+
+  async addSource (channel) {
+    this.#sources.add(channel)
+    this.#setupChannel(channel)
+
+    // This has been closed on the other side.
+    // Pending messages will be silently discarded by Node (as postMessage does not throw) so we don't need to handle them.
+    channel.on('close', () => {
+      this.#sources.delete(channel)
+    })
+  }
+
+  _send (request, context) {
+    const { channel, transferList } = context
+
+    if (context.trackResponse) {
+      const service = context.service
+      channel[kPendingResponses].set(request.reqId, { service, request })
+    }
+
+    channel.postMessage(sanitize(request, transferList), { transferList })
+  }
+
+  _createClosePromise () {
+    const { promise, resolve, reject } = withResolvers()
+    this.#closeResolvers = { resolve, reject }
+    return promise
+  }
+
+  _close () {
+    this.#closeResolvers.resolve()
+    this.#broadcastChannel.close()
+
+    for (const source of this.#sources) {
+      source.close()
+    }
+
+    for (const worker of this.#workers.values()) {
+      worker.channel?.close()
+    }
+
+    this.#sources.clear()
+  }
+
+  #setupChannel (channel) {
+    // Setup the message for processing
+    channel.on('message', event => {
+      this.#listener(event, { channel })
+    })
+  }
+
+  #updateWorkers (event) {
+    // Gather all existing channels by thread, it will make them reusable
+    const existingChannels = new Map()
+    for (const source of this.#workers.values()) {
+      existingChannels.set(source.thread, source.channel)
+    }
+
+    // Create a brand new map
+    this.#workers = new RoundRobinMap()
+
+    const instances = []
+    for (const [service, workers] of event.data) {
+      const count = workers.length
+      const next = Math.floor(Math.random() * count)
+
+      instances.push({ id: service, next, workers: count })
+
+      for (let i = 0; i < count; i++) {
+        const worker = workers[i]
+        const channel = existingChannels.get(worker.thread)
+
+        // Note i is not the worker index as in runtime, but the index in the list of current alive workers for the service
+        this.#workers.set(`${service}:${i}`, { ...worker, channel })
+      }
+    }
+
+    this.#workers.configure(instances)
+  }
+
+  #handlePendingResponse (channel) {
+    for (const { service, request } of channel[kPendingResponses].values()) {
+      this._emitResponse(
+        generateResponse(
+          request,
+          new errors.MessagingError(service, 'The communication channel was closed before receiving a response.'),
+          null
+        )
+      )
+    }
+
+    channel[kPendingResponses].clear()
+  }
+}
+
+module.exports = { MessagingITC }

package/lib/worker/round-robin-map.js

@@ -16,7 +16,7 @@ class RoundRobinMap extends Map {
     this.#instances = {}
 
     for (const service of services) {
-      this.#instances[service.id] = { next: 0, count: service.workers }
+      this.#instances[service.id] = { next: service.next ?? 0, count: service.workers }
     }
   }
 

package/lib/worker/symbols.js

@@ -9,10 +9,14 @@ const kITC = Symbol.for('plt.runtime.itc')
 const kHealthCheckTimer = Symbol.for('plt.runtime.worker.healthCheckTimer')
 const kWorkerStatus = Symbol('plt.runtime.worker.status')
 const kInterceptors = Symbol.for('plt.runtime.worker.interceptors')
+const kLastELU = Symbol.for('plt.runtime.worker.lastELU')
 
 // This string marker should be safe to use since it belongs to Unicode private area
 const kStderrMarker = '\ue002'
 
+// Note that this is used to create a BroadcastChannel so it must be a string
+const kWorkersBroadcast = 'plt.runtime.workers'
+
 module.exports = {
   kConfig,
   kId,
@@ -21,7 +25,9 @@ module.exports = {
   kWorkerId,
   kITC,
   kHealthCheckTimer,
+  kLastELU,
   kWorkerStatus,
   kStderrMarker,
-  kInterceptors
+  kInterceptors,
+  kWorkersBroadcast
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "2.69.0",
+  "version": "2.70.1",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -37,12 +37,12 @@
     "typescript": "^5.5.4",
     "undici-oidc-interceptor": "^0.5.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/composer": "2.69.0",
-    "@platformatic/db": "2.69.0",
-    "@platformatic/node": "2.69.0",
-    "@platformatic/service": "2.69.0",
-    "@platformatic/sql-graphql": "2.69.0",
-    "@platformatic/sql-mapper": "2.69.0"
+    "@platformatic/composer": "2.70.1",
+    "@platformatic/node": "2.70.1",
+    "@platformatic/service": "2.70.1",
+    "@platformatic/sql-graphql": "2.70.1",
+    "@platformatic/sql-mapper": "2.70.1",
+    "@platformatic/db": "2.70.1"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
@@ -50,7 +50,6 @@
     "@fastify/websocket": "^11.0.0",
     "@hapi/topo": "^6.0.2",
     "@opentelemetry/api": "^1.8.0",
-    "@platformatic/http-metrics": "^0.2.1",
     "@platformatic/undici-cache-memory": "^0.8.1",
     "@watchable/unpromise": "^1.0.2",
     "change-case-all": "^2.1.0",
@@ -75,25 +74,26 @@
     "sonic-boom": "^4.2.0",
     "tail-file-stream": "^0.2.0",
     "undici": "^7.0.0",
-    "undici-thread-interceptor": "^0.13.1",
+    "undici-thread-interceptor": "^0.14.0",
     "ws": "^8.16.0",
-    "@platformatic/basic": "2.69.0",
-    "@platformatic/config": "2.69.0",
-    "@platformatic/generators": "2.69.0",
-    "@platformatic/itc": "2.69.0",
-    "@platformatic/telemetry": "2.69.0",
-    "@platformatic/ts-compiler": "2.69.0",
-    "@platformatic/utils": "2.69.0"
+    "@platformatic/config": "2.70.1",
+    "@platformatic/basic": "2.70.1",
+    "@platformatic/generators": "2.70.1",
+    "@platformatic/itc": "2.70.1",
+    "@platformatic/metrics": "2.70.1",
+    "@platformatic/telemetry": "2.70.1",
+    "@platformatic/ts-compiler": "2.70.1",
+    "@platformatic/utils": "2.70.1"
   },
   "scripts": {
-    "test": "pnpm run lint && borp --concurrency=1 --timeout=600000 && tsd",
-    "test:main": "borp --concurrency=1 --timeout=300000 test/*.test.js test/*.test.mjs test/versions/*.test.js test/versions/*.test.mjs",
-    "test:api": "borp --concurrency=1 --timeout=300000 test/api/*.test.js test/api/*.test.mjs test/management-api/*.test.js test/management-api/*.test.mjs",
-    "test:cli": "borp --concurrency=1 --timeout=300000 test/cli/*.test.js test/cli/*.test.mjs test/cli/**/*.test.js test/cli/**/*.test.mjs",
-    "test:start": "borp --concurrency=1 --timeout=300000 test/start/*.test.js test/start/*.test.mjs",
-    "test:multiple-workers": "borp --concurrency=1 --timeout=600000 test/multiple-workers/*.test.js test/multiple-workers/*.test.mjs",
+    "test": "pnpm run lint && borp --concurrency=1 --timeout=1200000 && tsd",
+    "test:main": "borp --concurrency=1 --timeout=1200000 test/*.test.js test/*.test.mjs test/versions/*.test.js test/versions/*.test.mjs",
+    "test:api": "borp --concurrency=1 --timeout=1200000 test/api/*.test.js test/api/*.test.mjs test/management-api/*.test.js test/management-api/*.test.mjs",
+    "test:cli": "borp --concurrency=1 --timeout=1200000 test/cli/*.test.js test/cli/*.test.mjs test/cli/**/*.test.js test/cli/**/*.test.mjs",
+    "test:start": "borp --concurrency=1 --timeout=1200000 test/start/*.test.js test/start/*.test.mjs",
+    "test:multiple-workers": "borp --concurrency=1 --timeout=1200000 test/multiple-workers/*.test.js test/multiple-workers/*.test.mjs",
     "test:types": "tsd",
-    "coverage": "pnpm run lint && borp -X fixtures -X test -C --concurrency=1 --timeout=300000 && tsd",
+    "coverage": "pnpm run lint && borp -X fixtures -X test -C --concurrency=1 --timeout=1200000 && tsd",
     "gen-schema": "node lib/schema.js > schema.json",
     "gen-types": "json2ts > config.d.ts < schema.json",
     "build": "pnpm run gen-schema && pnpm run gen-types",

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/2.69.0.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/2.70.1.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "type": "object",
   "properties": {
@@ -76,6 +76,7 @@
               },
               "health": {
                 "type": "object",
+                "default": {},
                 "properties": {
                   "enabled": {
                     "anyOf": [
@@ -156,8 +157,15 @@
                     ]
                   },
                   "maxYoungGeneration": {
-                    "type": "number",
-                    "minimum": 0
+                    "anyOf": [
+                      {
+                        "type": "number",
+                        "minimum": 0
+                      },
+                      {
+                        "type": "string"
+                      }
+                    ]
                   }
                 },
                 "additionalProperties": false
@@ -244,6 +252,7 @@
           },
           "health": {
             "type": "object",
+            "default": {},
             "properties": {
               "enabled": {
                 "anyOf": [
@@ -324,8 +333,15 @@
                 ]
               },
               "maxYoungGeneration": {
-                "type": "number",
-                "minimum": 0
+                "anyOf": [
+                  {
+                    "type": "number",
+                    "minimum": 0
+                  },
+                  {
+                    "type": "string"
+                  }
+                ]
               }
             },
             "additionalProperties": false
@@ -477,6 +493,7 @@
           },
           "health": {
             "type": "object",
+            "default": {},
             "properties": {
               "enabled": {
                 "anyOf": [
@@ -557,8 +574,15 @@
                 ]
               },
               "maxYoungGeneration": {
-                "type": "number",
-                "minimum": 0
+                "anyOf": [
+                  {
+                    "type": "number",
+                    "minimum": 0
+                  },
+                  {
+                    "type": "string"
+                  }
+                ]
               }
             },
             "additionalProperties": false
@@ -976,7 +1000,6 @@
       "default": {},
       "properties": {
         "enabled": {
-          "default": true,
           "anyOf": [
             {
               "type": "boolean"
@@ -984,10 +1007,10 @@
             {
               "type": "string"
             }
-          ]
+          ],
+          "default": true
         },
         "interval": {
-          "default": 30000,
           "anyOf": [
             {
               "type": "number",
@@ -996,10 +1019,10 @@
             {
               "type": "string"
             }
-          ]
+          ],
+          "default": 30000
         },
         "gracePeriod": {
-          "default": 30000,
           "anyOf": [
             {
               "type": "number",
@@ -1008,10 +1031,10 @@
             {
               "type": "string"
             }
-          ]
+          ],
+          "default": 30000
         },
         "maxUnhealthyChecks": {
-          "default": 10,
           "anyOf": [
             {
               "type": "number",
@@ -1020,10 +1043,10 @@
             {
               "type": "string"
             }
-          ]
+          ],
+          "default": 10
         },
         "maxELU": {
-          "default": 0.99,
           "anyOf": [
             {
               "type": "number",
@@ -1033,10 +1056,10 @@
             {
               "type": "string"
             }
-          ]
+          ],
+          "default": 0.99
         },
         "maxHeapUsed": {
-          "default": 0.99,
           "anyOf": [
             {
               "type": "number",
@@ -1046,10 +1069,10 @@
             {
               "type": "string"
             }
-          ]
+          ],
+          "default": 0.99
         },
         "maxHeapTotal": {
-          "default": 4294967296,
           "anyOf": [
             {
               "type": "number",
@@ -1058,11 +1081,19 @@
             {
               "type": "string"
             }
-          ]
+          ],
+          "default": 4294967296
         },
         "maxYoungGeneration": {
-          "type": "number",
-          "minimum": 0
+          "anyOf": [
+            {
+              "type": "number",
+              "minimum": 0
+            },
+            {
+              "type": "string"
+            }
+          ]
         }
       },
       "additionalProperties": false
@@ -1537,6 +1568,18 @@
       ],
       "default": 300000
     },
+    "messagingTimeout": {
+      "anyOf": [
+        {
+          "type": "number",
+          "minimum": 1
+        },
+        {
+          "type": "string"
+        }
+      ],
+      "default": 30000
+    },
     "resolvedServicesBasePath": {
       "type": "string",
       "default": "external"