@platformatic/basic 3.0.0-alpha.6 → 3.0.0-rc.1

package/config.d.ts

@@ -98,6 +98,7 @@ export interface PlatformaticBasicConfig {
     };
     startTimeout?: number;
     restartOnError?: boolean | number;
+    exitOnUnhandledErrors?: boolean;
     gracefulShutdown?: {
       runtime: number | string;
       application: number | string;

package/index.d.ts

@@ -2,12 +2,6 @@ export interface StartOptions {
   listen?: boolean
 }
 
-export interface Dependency {
-  id: string
-  url?: string
-  local: boolean
-}
-
 export type BaseContext = Partial<{
   applicationId: string
   isEntrypoint: boolean
@@ -75,7 +69,6 @@ export class BaseCapability<Config = Record<string, any>, Options = BaseOptions>
     body: object
   }>
   log (options: { message: string; level: string }): Promise<void>
-  getBootstrapDependencies (): Promise<Dependency[]>
   getWatchConfig (): Promise<{
     enabled: boolean
     path: string

package/lib/capability.js

@@ -1,4 +1,11 @@
-import { buildPinoOptions, deepmerge, executeWithTimeout, kMetadata, kTimeout } from '@platformatic/foundation'
+import {
+  buildPinoOptions,
+  deepmerge,
+  executeWithTimeout,
+  kHandledError,
+  kMetadata,
+  kTimeout
+} from '@platformatic/foundation'
 import { client, collectMetrics, ensureMetricsGroup } from '@platformatic/metrics'
 import { parseCommandString } from 'execa'
 import { spawn } from 'node:child_process'
@@ -14,16 +21,44 @@ import { ChildManager } from './worker/child-manager.js'
 const kITC = Symbol.for('plt.runtime.itc')
 
 export class BaseCapability extends EventEmitter {
-  childManager
-  subprocess
+  status
+  type
+  version
+  root
+  config
+  context
+  standardStreams
+
+  applicationId
+  workerId
+  telemetryConfig
+  serverConfig
+  openapiSchema
+  graphqlSchema
+  connectionString
+  basePath
+  isEntrypoint
+  isProduction
+  dependencies
+  customHealthCheck
+  customReadinessCheck
+  clientWs
+  runtimeConfig
+  stdout
+  stderr
   subprocessForceClose
   subprocessTerminationSignal
+  logger
+  metricsRegistr
+
   #subprocessStarted
   #metricsCollected
+  #pendingDependenciesWaits
 
   constructor (type, version, root, config, context, standardStreams = {}) {
     super()
 
+    this.status = ''
     this.type = type
     this.version = version
     this.root = root
@@ -42,7 +77,7 @@ export class BaseCapability extends EventEmitter {
     this.basePath = null
     this.isEntrypoint = this.context.isEntrypoint
     this.isProduction = this.context.isProduction
-    this.#metricsCollected = false
+    this.dependencies = this.context.dependencies ?? []
     this.customHealthCheck = null
     this.customReadinessCheck = null
     this.clientWs = null
@@ -51,11 +86,11 @@ export class BaseCapability extends EventEmitter {
     this.stderr = standardStreams?.stderr ?? process.stderr
     this.subprocessForceClose = false
     this.subprocessTerminationSignal = 'SIGINT'
-
     this.logger = this._initializeLogger()
 
     // Setup globals
     this.registerGlobals({
+      capability: this,
       applicationId: this.applicationId,
       workerId: this.workerId,
       logLevel: this.logger.level,
@@ -79,10 +114,25 @@ export class BaseCapability extends EventEmitter {
       this.metricsRegistry = new client.Registry()
       this.registerGlobals({ prometheus: { client, registry: this.metricsRegistry } })
     }
+
+    this.#metricsCollected = false
+    this.#pendingDependenciesWaits = new Set()
   }
 
-  init () {
-    return this.updateContext()
+  async init () {
+    if (this.status) {
+      return
+    }
+
+    // Wait for explicit dependencies to start
+    await this.waitForDependenciesStart(this.dependencies)
+
+    if (this.status === 'stopped') {
+      return
+    }
+
+    await this.updateContext()
+    this.status = 'init'
   }
 
   updateContext (_context) {
@@ -93,8 +143,12 @@ export class BaseCapability extends EventEmitter {
     throw new Error('BaseCapability.start must be overriden by the subclasses')
   }
 
-  stop () {
-    throw new Error('BaseCapability.stop must be overriden by the subclasses')
+  async stop () {
+    if (this.#pendingDependenciesWaits.size > 0) {
+      await Promise.allSettled(this.#pendingDependenciesWaits)
+    }
+
+    this.status = 'stopped'
   }
 
   build () {
@@ -110,6 +164,106 @@ export class BaseCapability extends EventEmitter {
     throw new Error('BaseCapability.inject must be overriden by the subclasses')
   }
 
+  async waitForDependenciesStart (dependencies = []) {
+    if (!globalThis[kITC]) {
+      return
+    }
+
+    const pending = new Set(dependencies)
+
+    // Ask the runtime the status of the dependencies and don't wait if they are already started
+    const workers = await globalThis[kITC].send('getWorkers')
+
+    for (const worker of Object.values(workers)) {
+      if (this.dependencies.includes(worker.application) && worker.status === 'started') {
+        pending.delete(worker.application)
+      }
+    }
+
+    if (!pending.size) {
+      return
+    }
+
+    this.logger.info({ dependencies: Array.from(pending) }, 'Waiting for dependencies to start.')
+
+    const { promise, resolve, reject } = Promise.withResolvers()
+
+    function runtimeEventHandler ({ event, payload }) {
+      if (event !== 'application:worker:started') {
+        return
+      }
+
+      pending.delete(payload.application)
+
+      if (pending.size === 0) {
+        cleanupEvents()
+        resolve()
+      }
+    }
+
+    function stopHandler () {
+      cleanupEvents()
+
+      const error = new Error('One of the service dependencies was unable to start.')
+      error.dependencies = dependencies
+      error[kHandledError] = true
+      reject(error)
+    }
+
+    const cleanupEvents = () => {
+      globalThis[kITC].removeListener('runtime:event', runtimeEventHandler)
+      this.context.controller.removeListener('stopping', stopHandler)
+      this.#pendingDependenciesWaits.delete(promise)
+    }
+
+    globalThis[kITC].on('runtime:event', runtimeEventHandler)
+    this.context.controller.on('stopping', stopHandler)
+    this.#pendingDependenciesWaits.add(promise)
+
+    return promise
+  }
+
+  async waitForDependentsStop (dependents = []) {
+    if (!globalThis[kITC]) {
+      return
+    }
+
+    const pending = new Set(dependents)
+
+    // Ask the runtime the status of the dependencies and don't wait if they are already stopped
+    const workers = await globalThis[kITC].send('getWorkers')
+
+    for (const worker of Object.values(workers)) {
+      if (this.dependencies.includes(worker.application) && worker.status === 'started') {
+        pending.delete(worker.application)
+      }
+    }
+
+    if (!pending.size) {
+      return
+    }
+
+    this.logger.info({ dependents: Array.from(pending) }, 'Waiting for dependents to stop.')
+
+    const { promise, resolve } = Promise.withResolvers()
+
+    function runtimeEventHandler ({ event, payload }) {
+      if (event !== 'application:worker:stopped') {
+        return
+      }
+
+      pending.delete(payload.application)
+
+      if (pending.size === 0) {
+        globalThis[kITC].removeListener('runtime:event', runtimeEventHandler)
+        resolve()
+      }
+    }
+
+    globalThis[kITC].on('runtime:event', runtimeEventHandler)
+    return promise
+  }
+
   getUrl () {
     return this.url
   }
@@ -145,7 +299,7 @@ export class BaseCapability extends EventEmitter {
   }
 
   async getInfo () {
-    return { type: this.type, version: this.version }
+    return { type: this.type, version: this.version, dependencies: this.dependencies }
   }
 
   getDispatchFunc () {
@@ -304,6 +458,11 @@ export class BaseCapability extends EventEmitter {
       this.basePath = path
     })
 
+    this.childManager.on('event', event => {
+      globalThis[kITC].notify('event', event)
+      this.emit('application:worker:event', config)
+    })
+
     // This is not really important for the URL but sometimes it also a sign
     // that the process has been replaced and thus we need to update the client WebSocket
     this.childManager.on('url', (url, clientWs) => {
@@ -389,6 +548,7 @@ export class BaseCapability extends EventEmitter {
       isEntrypoint: this.isEntrypoint,
       runtimeBasePath: this.runtimeConfig?.basePath ?? null,
       wantsAbsoluteUrls: meta.gateway?.wantsAbsoluteUrls ?? false,
+      exitOnUnhandledErrors: this.runtimeConfig.exitOnUnhandledErrors ?? true,
       /* c8 ignore next 2 - else */
       port: (this.isEntrypoint ? this.serverConfig?.port || 0 : undefined) ?? true,
       host: (this.isEntrypoint ? this.serverConfig?.hostname : undefined) ?? true,
@@ -559,6 +719,13 @@ export class BaseCapability extends EventEmitter {
     globalThis.platformatic.onHttpStatsSize = (url, val) => {
       httpStatsSizeMetric.set({ dispatcher_stats_url: url }, val)
     }
+
+    const activeResourcesEventLoopMetric = new client.Gauge({
+      name: 'active_resources_event_loop',
+      help: 'Number of active resources keeping the event loop alive',
+      registers: [registry]
+    })
+    globalThis.platformatic.onActiveResourcesEventLoop = val => activeResourcesEventLoopMetric.set(val)
   }
 
   async #invalidateHttpCache (opts = {}) {

package/lib/worker/child-process.js

@@ -112,7 +112,11 @@ export class ChildProcess extends ITC {
 
     this.listen()
     this.#setupLogger()
-    this.#setupHandlers()
+
+    if (globalThis.platformatic.exitOnUnhandledErrors) {
+      this.#setupHandlers()
+    }
+
     this.#setupServer()
     this.#setupInterceptors()
 
@@ -282,6 +286,13 @@ export class ChildProcess extends ITC {
     globalThis.platformatic.onHttpStatsSize = (url, val) => {
       httpStatsSizeMetric.set({ dispatcher_stats_url: url }, val)
     }
+
+    const activeResourcesEventLoopMetric = new client.Gauge({
+      name: 'active_resources_event_loop',
+      help: 'Number of active resources keeping the event loop alive',
+      registers: [registry]
+    })
+    globalThis.platformatic.onActiveResourcesEventLoop = val => activeResourcesEventLoopMetric.set(val)
   }
 
   async #getMetrics ({ format } = {}) {
@@ -397,6 +408,14 @@ export class ChildProcess extends ITC {
 
     process.on('uncaughtException', handleUnhandled.bind(this, 'uncaught exception'))
     process.on('unhandledRejection', handleUnhandled.bind(this, 'unhandled rejection'))
+
+    process.on('newListener', event => {
+      if (event === 'uncaughtException' || event === 'unhandledRejection') {
+        this.#logger.warn(
+          `A listener has been added for the "process.${event}" event. This listener will be never triggered as Watt default behavior will kill the process before.\n To disable this behavior, set "exitOnUnhandledErrors" to false in the runtime config.`
+        )
+      }
+    })
   }
 
   #notifyConfig (config) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/basic",
-  "version": "3.0.0-alpha.6",
+  "version": "3.0.0-rc.1",
   "description": "",
   "main": "index.js",
   "types": "index.d.ts",
@@ -25,10 +25,10 @@
     "split2": "^4.2.0",
     "undici": "^7.0.0",
     "ws": "^8.18.0",
-    "@platformatic/itc": "3.0.0-alpha.6",
-    "@platformatic/foundation": "3.0.0-alpha.6",
-    "@platformatic/metrics": "3.0.0-alpha.6",
-    "@platformatic/telemetry": "3.0.0-alpha.6"
+    "@platformatic/foundation": "3.0.0-rc.1",
+    "@platformatic/itc": "3.0.0-rc.1",
+    "@platformatic/metrics": "3.0.0-rc.1",
+    "@platformatic/telemetry": "3.0.0-rc.1"
   },
   "devDependencies": {
     "cleaner-spec-reporter": "^0.5.0",
@@ -47,7 +47,7 @@
     "test": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/*.test.js test/**/*.test.js",
     "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",
+    "build": "npm run gen-schema && npm run gen-types",
     "lint": "eslint"
   }
 }

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/basic/3.0.0-alpha.6.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/basic/3.0.0-rc.1.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Basic Config",
   "type": "object",
@@ -175,6 +175,13 @@
                 },
                 "additionalProperties": false
               },
+              "dependencies": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                },
+                "default": []
+              },
               "arguments": {
                 "type": "array",
                 "items": {
@@ -556,6 +563,10 @@
             }
           ]
         },
+        "exitOnUnhandledErrors": {
+          "default": true,
+          "type": "boolean"
+        },
         "gracefulShutdown": {
           "type": "object",
           "properties": {

package/lib/worker/child-transport.js

@@ -1,59 +0,0 @@
-import { ensureLoggableError } from '@platformatic/foundation'
-import { generateRequest, sanitize } from '@platformatic/itc/lib/index.js'
-import { once } from 'node:events'
-import { platform } from 'node:os'
-import { workerData } from 'node:worker_threads'
-import build from 'pino-abstract-transport'
-import { WebSocket } from 'ws'
-import { getSocketPath } from './child-manager.js'
-
-/* c8 ignore next 5 */
-function logDirectError (message, error) {
-  process._rawDebug(`Logger thread for child process of application ${workerData.id} ${message}.`, {
-    error: ensureLoggableError(error)
-  })
-}
-
-/* c8 ignore next 4 */
-function handleUnhandled (type, error) {
-  logDirectError(`threw an ${type}`, error)
-  process.exit(6)
-}
-
-process.on('uncaughtException', handleUnhandled.bind(null, 'uncaught exception'))
-process.on('unhandledRejection', handleUnhandled.bind(null, 'unhandled rejection'))
-
-export default async function () {
-  try {
-    /* c8 ignore next */
-    const protocol = platform() === 'win32' ? 'ws+unix:' : 'ws+unix://'
-    const socket = new WebSocket(`${protocol}${getSocketPath(process.env.PLT_MANAGER_ID)}`)
-
-    await once(socket, 'open')
-
-    // Do not process responses but empty the socket inbound queue
-    socket.on('message', () => {})
-
-    /* c8 ignore next 3 */
-    socket.on('error', error => {
-      logDirectError('threw a socket error', error)
-    })
-
-    return build(
-      async function (source) {
-        for await (const obj of source) {
-          socket.send(JSON.stringify(sanitize(generateRequest('log', { logs: [obj] }))))
-        }
-      },
-      {
-        close (_, cb) {
-          socket.close()
-          cb()
-        }
-      }
-    )
-    /* c8 ignore next 3 */
-  } catch (error) {
-    logDirectError('threw a connection error', error)
-  }
-}