@platformatic/runtime 3.55.0 → 3.57.0

package/lib/worker/health-signals.js

@@ -1,3 +1,4 @@
+import { getITC, updateGlobals } from '@platformatic/globals'
 import {
   HealthSignalMustBeObjectError,
   HealthSignalTypeMustBeStringError
@@ -60,7 +61,8 @@ export function initHealthSignalsApi (options = {}) {
           isSending = false
           try {
             const signals = queue.getAll()
-            await globalThis.platformatic.itc.send('sendHealthSignals', {
+            const itc = getITC()
+            await itc.send('sendHealthSignals', {
               workerId,
               signals
             })
@@ -76,5 +78,5 @@ export function initHealthSignalsApi (options = {}) {
     return promise
   }
 
-  globalThis.platformatic.sendHealthSignal = sendHealthSignal
+  updateGlobals({ sendHealthSignal })
 }

package/lib/worker/http-cache.js

@@ -1,7 +1,7 @@
+import { getClientSpansAls, getITC } from '@platformatic/globals'
 import { randomUUID } from 'node:crypto'
 import { Readable, Writable } from 'node:stream'
 import { interceptors } from 'undici'
-import { kITC } from './symbols.js'
 
 const kCacheIdHeader = Symbol('cacheIdHeader')
 const CACHE_ID_HEADER = 'x-plt-http-cache-id'
@@ -28,7 +28,7 @@ export class RemoteCacheStore {
       this.#logger.error(err, 'Error in onRequest http cache hook')
     }
 
-    const itc = globalThis[kITC]
+    const itc = getITC()
     if (!itc) return
 
     const sanitizedRequest = this.#sanitizeRequest(request)
@@ -68,7 +68,7 @@ export class RemoteCacheStore {
       value.headers = { ...value.headers, [CACHE_ID_HEADER]: cacheEntryId }
     }
 
-    const itc = globalThis[kITC]
+    const itc = getITC()
     if (!itc) throw new Error('Cannot write to cache without an ITC instance')
 
     const acc = []
@@ -96,7 +96,7 @@ export class RemoteCacheStore {
   }
 
   delete (request) {
-    const itc = globalThis[kITC]
+    const itc = getITC()
     if (!itc) throw new Error('Cannot delete from cache without an ITC instance')
 
     request = this.#sanitizeRequest(request)
@@ -120,7 +120,7 @@ export function httpCacheInterceptor (interceptorOpts) {
 
   // AsyncLocalStorage that contains a client http request span
   // Exists only when the nodejs capability telemetry is enabled
-  const clientSpansAls = globalThis.platformatic.clientSpansAls
+  const clientSpansAls = getClientSpansAls({ throwOnMissing: false })
 
   return originalDispatch => {
     const dispatch = (opts, handler) => {

package/lib/worker/interceptors.js

@@ -1,14 +1,46 @@
-import { mirrorGlobalDispatcherForBuiltinFetch } from '@platformatic/foundation'
+import { getGlobalDispatcherFromKnownUndiciSymbols, mirrorGlobalDispatcherForBuiltinFetch } from '@platformatic/foundation'
+import {
+  getInterceptors,
+  getLogger,
+  getOnHttpCacheHit,
+  getOnHttpCacheMiss,
+  getOnHttpCacheRequest
+} from '@platformatic/globals'
 import { createTelemetryThreadInterceptorHooks } from '@platformatic/telemetry'
 import { createRequire } from 'node:module'
 import { join } from 'node:path'
 import { pathToFileURL } from 'node:url'
 import { parentPort, workerData } from 'node:worker_threads'
-import { Agent, Client, Pool, setGlobalDispatcher } from 'undici'
+import { Agent, Client, Pool } from 'undici'
 import { wire } from 'undici-thread-interceptor'
 import { createChannelCreationHook } from '../policies.js'
 import { RemoteCacheStore, httpCacheInterceptor } from './http-cache.js'
-import { kInterceptors } from './symbols.js'
+
+const kPlatformaticGlobalDispatcher = Symbol.for('platformatic.undici.globalDispatcher')
+
+let composeRuntimeDispatcher
+
+export function markAsPlatformaticDispatcher (dispatcher) {
+  Object.defineProperty(dispatcher, kPlatformaticGlobalDispatcher, {
+    value: true,
+    enumerable: false,
+    configurable: true
+  })
+}
+
+export function refreshGlobalDispatcher () {
+  if (!composeRuntimeDispatcher) {
+    return false
+  }
+
+  const dispatcher = getGlobalDispatcherFromKnownUndiciSymbols()
+  if (!dispatcher || dispatcher[kPlatformaticGlobalDispatcher]) {
+    return false
+  }
+
+  composeRuntimeDispatcher(dispatcher)
+  return true
+}
 
 export async function setDispatcher (runtimeConfig) {
   const threadDispatcher = createThreadInterceptor(runtimeConfig)
@@ -28,17 +60,39 @@ export async function setDispatcher (runtimeConfig) {
 
   const dispatcherOpts = await getDispatcherOpts(runtimeConfig.undici)
 
-  const dispatcher = new Agent(dispatcherOpts).compose(
-    [threadInterceptor, ...userInterceptors, cacheInterceptor].filter(Boolean)
-  )
-  setGlobalDispatcher(dispatcher)
-  mirrorGlobalDispatcherForBuiltinFetch(dispatcher)
+  function installDispatcher (baseDispatcher) {
+    const dispatcher = baseDispatcher.compose(
+      [threadInterceptor, ...userInterceptors, cacheInterceptor].filter(Boolean)
+    )
+
+    markAsPlatformaticDispatcher(dispatcher)
+    mirrorGlobalDispatcherForBuiltinFetch(dispatcher, createLegacyDispatcher(dispatcher))
+    return dispatcher
+  }
+
+  composeRuntimeDispatcher = installDispatcher
+  installDispatcher(new Agent(dispatcherOpts))
 
   return { threadDispatcher }
 }
 
+function createLegacyDispatcher (dispatcher) {
+  const legacyDispatcher = globalThis[Symbol.for('undici.globalDispatcher.1')]
+  const currentDispatcher = globalThis[Symbol.for('undici.globalDispatcher.2')]
+
+  if (legacyDispatcher && legacyDispatcher !== currentDispatcher && legacyDispatcher.constructor?.name === 'Dispatcher1Wrapper') {
+    try {
+      return new legacyDispatcher.constructor(dispatcher)
+    } catch {
+      return dispatcher
+    }
+  }
+
+  return dispatcher
+}
+
 export async function updateUndiciInterceptors (undiciConfig) {
-  const updatableInterceptors = globalThis[kInterceptors]
+  const updatableInterceptors = getInterceptors()
   if (!updatableInterceptors) return
 
   if (Array.isArray(undiciConfig?.interceptors)) {
@@ -98,11 +152,7 @@ async function loadInterceptors (_require, interceptorsConfigs, key) {
 }
 
 async function loadInterceptor (_require, interceptorConfig, key) {
-  let updatableInterceptors = globalThis[kInterceptors]
-  if (!updatableInterceptors) {
-    updatableInterceptors = {}
-    globalThis[kInterceptors] = updatableInterceptors
-  }
+  const updatableInterceptors = getInterceptors()
 
   const { module, options } = interceptorConfig
 
@@ -199,24 +249,34 @@ function parseOrigins (origins) {
 
 function createHttpCacheInterceptor (runtimeConfig) {
   const httpCache = runtimeConfig.httpCache
+
   const cacheInterceptor = httpCacheInterceptor({
     store: new RemoteCacheStore({
       onRequest: opts => {
-        globalThis.platformatic?.onHttpCacheRequest?.(opts)
+        const onHttpCacheRequest = getOnHttpCacheRequest({ throwOnMissing: false })
+        if (onHttpCacheRequest) {
+          onHttpCacheRequest(opts)
+        }
       },
       onCacheHit: opts => {
-        globalThis.platformatic?.onHttpCacheHit?.(opts)
+        const onHttpCacheHit = getOnHttpCacheHit({ throwOnMissing: false })
+        if (onHttpCacheHit) {
+          onHttpCacheHit(opts)
+        }
       },
       onCacheMiss: opts => {
-        globalThis.platformatic?.onHttpCacheMiss?.(opts)
+        const onHttpCacheMiss = getOnHttpCacheMiss({ throwOnMissing: false })
+        if (onHttpCacheMiss) {
+          onHttpCacheMiss(opts)
+        }
       },
-      logger: globalThis.platformatic.logger
+      logger: getLogger()
     }),
     methods: httpCache.methods ?? ['GET', 'HEAD'],
     origins: parseOrigins(httpCache.origins),
     cacheByDefault: httpCache.cacheByDefault,
     type: httpCache.type,
-    logger: globalThis.platformatic.logger
+    logger: getLogger()
   })
   return cacheInterceptor
 }

package/lib/worker/itc.js

@@ -1,4 +1,5 @@
 import { ensureLoggableError, executeInParallel, executeWithTimeout, kTimeout } from '@platformatic/foundation'
+import { getEvents, getLogger, getMessaging, updateGlobals } from '@platformatic/globals'
 import { initializeITCTelemetry, ITC } from '@platformatic/itc'
 import { Unpromise } from '@watchable/unpromise'
 import { once } from 'node:events'
@@ -150,10 +151,10 @@ export async function waitEventFromITC (worker, event) {
 export async function setupITC (controller, application, dispatcher, sharedContext) {
   await initializeITCTelemetry()
 
-  const logger = globalThis.platformatic.logger
+  const logger = getLogger()
   const messaging = new MessagingITC(controller.applicationConfig.id, workerData.config, logger)
 
-  Object.assign(globalThis.platformatic ?? {}, {
+  updateGlobals({
     messaging: {
       handle: messaging.handle.bind(messaging),
       send: messaging.send.bind(messaging),
@@ -172,7 +173,8 @@ export async function setupITC (controller, application, dispatcher, sharedConte
           await once(controller, 'start')
         } else {
           // This gives a chance to a capability to perform custom logic
-          globalThis.platformatic.events.emit('start')
+          const events = getEvents()
+          events.emit('start')
 
           try {
             await controller.start()
@@ -205,7 +207,8 @@ export async function setupITC (controller, application, dispatcher, sharedConte
 
         if (force || status.startsWith('start')) {
           // This gives a chance to a capability to perform custom logic
-          globalThis.platformatic.events.emit('stop')
+          const events = getEvents()
+          events.emit('stop')
 
           await controller.stop(force, dependents)
         }
@@ -419,9 +422,16 @@ export async function setupITC (controller, application, dispatcher, sharedConte
         // For service-based capabilities, expose the Fastify app
         replServer.context.app = controller.capability?.getApplication?.()
         replServer.context.capability = controller.capability
-        replServer.context.platformatic = globalThis.platformatic
+        replServer.context.platformatic = {
+          capability: controller.capability,
+          config: controller.config,
+          events: getEvents(),
+          itc,
+          logger: getLogger(),
+          messaging: getMessaging()
+        }
         replServer.context.config = controller.applicationConfig
-        replServer.context.logger = globalThis.platformatic?.logger
+        replServer.context.logger = getLogger()
 
         replServer.on('exit', () => {
           port.postMessage({ type: 'exit' })

package/lib/worker/main.js

@@ -6,6 +6,7 @@ import {
   getPrivateSymbol,
   parseMemorySize
 } from '@platformatic/foundation'
+import { getITC, getLogger, updateGlobals } from '@platformatic/globals'
 import { addPinoInstrumentation } from '@platformatic/telemetry'
 import { Buffer } from 'node:buffer'
 import { subscribe } from 'node:diagnostics_channel'
@@ -25,11 +26,12 @@ import { initHealthSignalsApi } from './health-signals.js'
 import { setDispatcher } from './interceptors.js'
 import { setupITC } from './itc.js'
 import { SharedContext } from './shared-context.js'
-import { kId, kITC, kStderrMarker } from './symbols.js'
+import { kStderrMarker } from './symbols.js'
 
 function handlePreInitializationUnhandled (type, err) {
   const label = `worker ${workerData.worker.index} of the application "${workerData.applicationConfig.id}"`
-  globalThis.platformatic.logger.error(
+  const logger = getLogger()
+  logger.error(
     { err: ensureLoggableError(err) },
     `The ${label} threw an ${type} before initialization.`
   )
@@ -38,7 +40,8 @@ function handlePreInitializationUnhandled (type, err) {
 
 class ForwardingEventEmitter extends EventEmitter {
   emitAndNotify (event, ...args) {
-    globalThis.platformatic.itc.notify('event', { event, payload: args })
+    const itc = getITC()
+    itc.notify('event', { event, payload: args })
     return this.emit(event, ...args)
   }
 }
@@ -201,8 +204,9 @@ async function main () {
   const cleanup = setupHandlers()
 
   installUndiciGlobals(globalThis)
-  globalThis[kId] = threadId
-  globalThis.platformatic = Object.assign(globalThis.platformatic ?? {}, {
+  updateGlobals({
+    runtimeId: threadId,
+    interceptors: {},
     logger: createLogger(),
     events: new ForwardingEventEmitter()
   })
@@ -210,11 +214,11 @@ async function main () {
   const runtimeConfig = workerData.config
   const applicationConfig = workerData.applicationConfig
 
-  setupBufferPool(runtimeConfig, applicationConfig, globalThis.platformatic.logger)
-  setupDefaultHighWaterMark(runtimeConfig, applicationConfig, globalThis.platformatic.logger)
+  setupBufferPool(runtimeConfig, applicationConfig, getLogger())
+  setupDefaultHighWaterMark(runtimeConfig, applicationConfig, getLogger())
 
   // Enable compile cache early before loading user modules
-  await setupCompileCache(runtimeConfig, applicationConfig, globalThis.platformatic.logger)
+  await setupCompileCache(runtimeConfig, applicationConfig, getLogger())
 
   await performPreloading(runtimeConfig, applicationConfig)
 
@@ -226,7 +230,8 @@ async function main () {
     envfile = resolve(workerData.applicationConfig.path, '.env')
   }
 
-  globalThis.platformatic.logger.debug({ envfile }, 'Loading envfile...')
+  const logger = getLogger()
+  logger.debug({ envfile }, 'Loading envfile...')
 
   try {
     process.loadEnvFile(envfile)
@@ -301,15 +306,16 @@ async function main () {
 
   const sharedContext = new SharedContext()
   // Limit the amount of methods a user can call
-  globalThis.platformatic.sharedContext = {
-    get: () => sharedContext.get(),
-    update: (...args) => sharedContext.update(...args)
-  }
+  updateGlobals({
+    sharedContext: {
+      get: () => sharedContext.get(),
+      update: (...args) => sharedContext.update(...args)
+    }
+  })
 
   // Setup interaction with parent port
   const itc = await setupITC(controller, applicationConfig, threadDispatcher, sharedContext)
-  globalThis[kITC] = itc
-  globalThis.platformatic.itc = itc
+  updateGlobals({ itc })
 
   // Setup management client for privileged applications
   if (applicationConfig.management) {
@@ -322,7 +328,7 @@ async function main () {
       const ops = typeof applicationConfig.management === 'object'
         ? applicationConfig.management.operations
         : undefined
-      globalThis.platformatic.management = new ManagementClient(ops)
+      updateGlobals({ management: new ManagementClient(ops) })
     }
   }
 

package/lib/worker/management.js

@@ -1,4 +1,4 @@
-import { kITC } from './symbols.js'
+import { getITC } from '@platformatic/globals'
 
 export class ManagementClient {
   #allowedOperations
@@ -14,7 +14,8 @@ export class ManagementClient {
       throw new Error(`Operation "${operation}" is not allowed`)
     }
 
-    return globalThis[kITC].send('management:' + operation, data)
+    const itc = getITC()
+    return itc.send('management:' + operation, data)
   }
 
   getRuntimeStatus () {

package/lib/worker/messaging.js

@@ -10,9 +10,10 @@ import {
   startOutgoingMessagingSpanSync,
   traceIncomingMessagingHandler
 } from '@platformatic/itc'
+import { getITC } from '@platformatic/globals'
 import { MessagingError } from '../errors.js'
 import { RoundRobinMap } from './round-robin-map.js'
-import { kITC, kWorkersBroadcast } from './symbols.js'
+import { kWorkersBroadcast } from './symbols.js'
 
 const kPendingResponses = Symbol('plt.messaging.pendingResponses')
 
@@ -76,7 +77,7 @@ export class MessagingITC extends ITC {
 
     try {
       // Get the next worker for the application
-      const worker = this.#workers.next(application)
+      const worker = this._getNextWorker(application)
 
       if (!worker) {
         throw new MessagingError(application, 'No workers available')
@@ -85,8 +86,9 @@ export class MessagingITC extends ITC {
       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 itc = getITC()
         const channel = await executeWithTimeout(
-          globalThis[kITC].send('getWorkerMessagingChannel', {
+          itc.send('getWorkerMessagingChannel', {
             id: this.#id,
             application: worker.application,
             worker: worker.worker
@@ -100,10 +102,7 @@ export class MessagingITC extends ITC {
         }
 
         worker.channel = channel
-        this.#setupChannel(channel)
-
-        channel[kPendingResponses] = new Map()
-        channel.on('close', this.#handlePendingResponse.bind(this, channel))
+        this._setupChannel(channel)
       }
 
       const context = { ...options }
@@ -164,13 +163,11 @@ export class MessagingITC extends ITC {
 
   async addSource (channel) {
     this.#sources.add(channel)
-    this.#setupChannel(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)
-    })
+  _getNextWorker (application) {
+    return this.#workers.next(application)
   }
 
   _send (request, context) {
@@ -181,7 +178,7 @@ export class MessagingITC extends ITC {
       channel[kPendingResponses].set(request.reqId, { application, request })
     }
 
-    channel.postMessage(sanitize(request, transferList), { transferList })
+    channel.postMessage(sanitize(request, transferList), transferList)
   }
 
   _createClosePromise () {
@@ -209,11 +206,22 @@ export class MessagingITC extends ITC {
     this.#sources.clear()
   }
 
-  #setupChannel (channel) {
+  _setupChannel (channel) {
+    if (channel[kPendingResponses]) {
+      return
+    }
+
+    channel[kPendingResponses] = new Map()
+
     // Setup the message for processing
     channel.on('message', event => {
       this.#listener(event, { channel, message: event })
     })
+
+    channel.on('close', () => {
+      this.#sources.delete(channel)
+      this.#handlePendingResponse(channel)
+    })
   }
 
   #updateWorkers (event) {

package/lib/worker/shared-context.js

@@ -1,4 +1,4 @@
-import { kITC } from './symbols.js'
+import { getITC } from '@platformatic/globals'
 
 export class SharedContext {
   constructor () {
@@ -6,12 +6,14 @@ export class SharedContext {
   }
 
   update (context, options = {}) {
-    return globalThis[kITC].send('updateSharedContext', { ...options, context })
+    const itc = getITC()
+    return itc.send('updateSharedContext', { ...options, context })
   }
 
   get () {
     if (this.sharedContext === null) {
-      this.sharedContext = globalThis[kITC].send('getSharedContext')
+      const itc = getITC()
+      this.sharedContext = itc.send('getSharedContext')
     }
     return this.sharedContext
   }

package/lib/worker/symbols.js

@@ -1,5 +1,5 @@
 export const kConfig = Symbol.for('plt.runtime.config')
-export const kId = Symbol.for('plt.runtime.id') // This is also used to detect if we are running in a Platformatic runtime thread
+export const kId = Symbol.for('plt.runtime.id')
 export const kFullId = Symbol.for('plt.runtime.fullId')
 export const kApplicationId = Symbol.for('plt.runtime.application.id')
 export const kWorkerId = Symbol.for('plt.runtime.worker.id')
@@ -8,7 +8,6 @@ export const kHealthCheckTimer = Symbol.for('plt.runtime.worker.healthCheckTimer
 export const kWorkerStatus = Symbol('plt.runtime.worker.status')
 export const kWorkerHealthSignals = Symbol.for('plt.runtime.worker.healthSignals')
 export const kWorkerStartTime = Symbol.for('plt.runtime.worker.startTime')
-export const kInterceptors = Symbol.for('plt.runtime.worker.interceptors')
 export const kLastHealthCheckELU = Symbol.for('plt.runtime.worker.lastHealthCheckELU')
 export const kLastWorkerScalerELU = Symbol.for('plt.runtime.worker.lastWorkerScalerELU')
 export const kInterceptorReadyPromise = Symbol.for('plt.runtime.worker.interceptorReadyPromise')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "3.55.0",
+  "version": "3.57.0",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -20,7 +20,7 @@
     "@fastify/formbody": "^8.0.0",
     "atomic-sleep": "^1.0.0",
     "autocannon": "^8.0.0",
-    "c8": "^10.0.0",
+    "c8": "^11.0.0",
     "cleaner-spec-reporter": "^0.5.0",
     "eslint": "9",
     "execa": "^9.0.0",
@@ -36,14 +36,14 @@
     "typescript": "^5.5.4",
     "undici-oidc-interceptor": "^0.5.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/db": "3.55.0",
-    "@platformatic/composer": "3.55.0",
-    "@platformatic/node": "3.55.0",
-    "@platformatic/service": "3.55.0",
-    "@platformatic/sql-graphql": "3.55.0",
-    "@platformatic/gateway": "3.55.0",
-    "@platformatic/sql-mapper": "3.55.0",
-    "@platformatic/wattpm-pprof-capture": "3.55.0"
+    "@platformatic/db": "3.57.0",
+    "@platformatic/node": "3.57.0",
+    "@platformatic/composer": "3.57.0",
+    "@platformatic/gateway": "3.57.0",
+    "@platformatic/service": "3.57.0",
+    "@platformatic/sql-graphql": "3.57.0",
+    "@platformatic/wattpm-pprof-capture": "3.57.0",
+    "@platformatic/sql-mapper": "3.57.0"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
@@ -70,15 +70,16 @@
     "semgrator": "^0.3.0",
     "sonic-boom": "^4.2.0",
     "systeminformation": "^5.27.11",
-    "undici": "^7.0.0",
+    "undici": "^7.27.2",
     "undici-thread-interceptor": "^1.3.1",
     "ws": "^8.16.0",
-    "@platformatic/itc": "3.55.0",
-    "@platformatic/foundation": "3.55.0",
-    "@platformatic/metrics": "3.55.0",
-    "@platformatic/basic": "3.55.0",
-    "@platformatic/generators": "3.55.0",
-    "@platformatic/telemetry": "3.55.0"
+    "@platformatic/basic": "3.57.0",
+    "@platformatic/globals": "3.57.0",
+    "@platformatic/generators": "3.57.0",
+    "@platformatic/foundation": "3.57.0",
+    "@platformatic/itc": "3.57.0",
+    "@platformatic/metrics": "3.57.0",
+    "@platformatic/telemetry": "3.57.0"
   },
   "engines": {
     "node": ">=22.19.0"