@platformatic/runtime 1.23.0 → 1.24.0

package/fixtures/configs/monorepo-hotreload.json

@@ -0,0 +1,27 @@
+{
+  "$schema": "https://platformatic.dev/schemas/v0.20.0/runtime",
+  "entrypoint": "serviceApp",
+  "allowCycles": true,
+  "hotReload": true,
+  "autoload": {
+    "path": "../monorepo",
+    "exclude": [
+      "docs",
+      "composerApp"
+    ],
+    "mappings": {
+      "serviceAppWithLogger": {
+        "id": "with-logger",
+        "config": "platformatic.service.json"
+      },
+      "serviceAppWithMultiplePlugins": {
+        "id": "multi-plugin-service",
+        "config": "platformatic.service.json"
+      },
+      "dbApp": {
+        "id": "db-app",
+        "config": "platformatic.db.json"
+      }
+    }
+  }
+}

package/fixtures/management-api/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "test-runtime-package",
+  "version": "1.0.42"
+}

package/fixtures/management-api/platformatic.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://platformatic.dev/schemas/v1.22.0/runtime",
+  "entrypoint": "service-1",
+  "allowCycles": true,
+  "hotReload": false,
+  "autoload": {
+    "path": "./services"
+  },
+  "managementApi": true
+}

package/fixtures/management-api/services/service-1/platformatic.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://platformatic.dev/schemas/v1.22.0/service",
+  "server": {
+    "hostname": "127.0.0.1",
+    "port": 0,
+    "logger": {
+      "name": "service-with-logger",
+      "level": "trace"
+    }
+  },
+  "service": {
+    "openapi": true
+  },
+  "plugins": {
+    "paths": ["plugin.js"]
+  },
+  "watch": true,
+  "metrics": {
+    "server": "parent"
+  }
+}

package/fixtures/management-api/services/service-1/plugin.js

@@ -0,0 +1,8 @@
+'use strict'
+
+/** @param {import('fastify').FastifyInstance} app */
+module.exports = async function (app) {
+  app.get('/hello', async () => {
+    return { service: 'service-2' }
+  })
+}

package/fixtures/management-api/services/service-2/platformatic.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://platformatic.dev/schemas/v1.22.0/service",
+  "server": {
+    "hostname": "127.0.0.1",
+    "port": 0
+  },
+  "service": {
+    "openapi": true
+  },
+  "plugins": {
+    "paths": ["plugin.js"]
+  }
+}

package/fixtures/management-api/services/service-2/plugin.js

@@ -0,0 +1,8 @@
+'use strict'
+
+/** @param {import('fastify').FastifyInstance} app */
+module.exports = async function (app, options) {
+  app.get('/hello', async () => {
+    return { service: 'service-2' }
+  })
+}

package/lib/api-client.js

@@ -3,6 +3,7 @@
 const { once, EventEmitter } = require('node:events')
 const { randomUUID } = require('node:crypto')
 const errors = require('./errors')
+const { setTimeout: sleep } = require('node:timers/promises')
 
 const MAX_LISTENERS_COUNT = 100
 
@@ -27,21 +28,36 @@ class RuntimeApiClient extends EventEmitter {
     return this.#sendCommand('plt:start-services')
   }
 
-  async stop () {
-    await this.#sendCommand('plt:stop-services')
-  }
-
   async close () {
     await this.#sendCommand('plt:stop-services')
 
     this.worker.postMessage({ command: 'plt:close' })
-    await this.#exitPromise
+    const res = await Promise.race([
+      this.#exitPromise,
+      // We must kill the worker if it doesn't exit in 10 seconds
+      // because it may be stuck in an infinite loop.
+      // This is a workaround for
+      // https://github.com/nodejs/node/issues/47748
+      // https://github.com/nodejs/node/issues/49344
+      // Remove once https://github.com/nodejs/node/pull/51290 is released
+      // on all lines.
+      // Likely to be removed when we drop support for Node.js 18.
+      sleep(10000, 'timeout', { ref: false })
+    ])
+
+    if (res === 'timeout') {
+      this.worker.unref()
+    }
   }
 
   async restart () {
     return this.#sendCommand('plt:restart-services')
   }
 
+  async getEntrypointDetails () {
+    return this.#sendCommand('plt:get-entrypoint-details')
+  }
+
   async getServices () {
     return this.#sendCommand('plt:get-services')
   }

package/lib/api.js

@@ -9,9 +9,11 @@ const { printSchema } = require('graphql')
 class RuntimeApi {
   #services
   #dispatcher
+  #logger
 
   constructor (config, logger, loaderPort) {
     this.#services = new Map()
+    this.#logger = logger
     const telemetryConfig = config.telemetry
 
     for (let i = 0; i < config.services.length; ++i) {
@@ -48,8 +50,21 @@ class RuntimeApi {
       const command = message?.command
       if (command) {
         if (command === 'plt:close') {
-          await this.#dispatcher.close()
-          process.exit() // Exit the worker thread.
+          // We close everything because they might be using
+          // a FinalizationRegistry and it may stuck us in an infinite loop.
+          // This is a workaround for
+          // https://github.com/nodejs/node/issues/47748
+          // https://github.com/nodejs/node/issues/49344
+          // Remove once https://github.com/nodejs/node/pull/51290 is released
+          // on all lines.
+          // Likely to be removed when we drop support for Node.js 18.
+          if (this.#dispatcher) {
+            await this.#dispatcher.close()
+          }
+          await this.stopServices()
+
+          setImmediate(process.exit) // Exit the worker thread.
+          return
         }
 
         const res = await this.#executeCommand(message)
@@ -97,6 +112,8 @@ class RuntimeApi {
         return this.stopServices(params)
       case 'plt:restart-services':
         return this.#restartServices(params)
+      case 'plt:get-entrypoint-details':
+        return this.#getEntrypointDetails(params)
       case 'plt:get-services':
         return this.#getServices(params)
       case 'plt:get-service-details':
@@ -162,6 +179,15 @@ class RuntimeApi {
     return entrypointUrl
   }
 
+  #getEntrypointDetails () {
+    for (const service of this.#services.values()) {
+      if (service.appConfig.entrypoint) {
+        return this.#getServiceDetails({ id: service.appConfig.id })
+      }
+    }
+    return null
+  }
+
   #getServices () {
     const services = { services: [] }
 
@@ -191,8 +217,15 @@ class RuntimeApi {
     const service = this.#getServiceById(id)
     const status = service.getStatus()
 
+    const type = service.config.configType
     const { entrypoint, dependencies, localUrl } = service.appConfig
-    return { id, status, localUrl, entrypoint, dependencies }
+    const serviceDetails = { id, type, status, localUrl, entrypoint, dependencies }
+
+    if (entrypoint) {
+      serviceDetails.url = status === 'started' ? service.server.url : null
+    }
+
+    return serviceDetails
   }
 
   #getServiceConfig ({ id }) {

package/lib/app.js

@@ -73,7 +73,10 @@ class PlatformaticApp {
       this.#setuplogger(this.config.configManager)
       await this.server.restart()
     } catch (err) {
-      this.#logAndExit(err)
+      // The restart failed. Log the error and
+      // wait for another event.
+      // The old app is still available
+      this.#logger.error({ err })
     }
 
     this.#restarting = false

package/lib/management-api.js

@@ -1,12 +1,31 @@
 'use strict'
 
+const { tmpdir, platform } = require('node:os')
+const { join } = require('node:path')
+const { readFile, mkdir, unlink } = require('node:fs/promises')
 const fastify = require('fastify')
-const { isatty } = require('tty')
+const { prettyFactory } = require('pino-pretty')
+const errors = require('./errors')
 const platformaticVersion = require('../package.json').version
 
-async function createManagementApi (config, runtimeApiClient) {
-  addManagementApiLogger(config)
-  const app = fastify(config)
+const PLATFORMATIC_TMP_DIR = join(tmpdir(), 'platformatic', 'pids')
+
+const pinoLogLevels = {
+  fatal: 60,
+  error: 50,
+  warn: 40,
+  info: 30,
+  debug: 20,
+  trace: 10
+}
+
+async function createManagementApi (configManager, runtimeApiClient, loggingPort) {
+  let apiConfig = configManager.current.managementApi
+  if (!apiConfig || apiConfig === true) {
+    apiConfig = {}
+  }
+
+  const app = fastify(apiConfig)
   app.log.warn(
     'Runtime Management API is in the experimental stage. ' +
     'The feature is not subject to semantic versioning rules. ' +
@@ -14,36 +33,57 @@ async function createManagementApi (config, runtimeApiClient) {
     'Use of the feature is not recommended in production environments.'
   )
 
+  async function getRuntimePackageJson (cwd) {
+    const packageJsonPath = join(cwd, 'package.json')
+    const packageJsonFile = await readFile(packageJsonPath, 'utf8')
+    const packageJson = JSON.parse(packageJsonFile)
+    return packageJson
+  }
+
+  app.register(require('@fastify/websocket'))
+
   app.register(async (app) => {
     app.get('/metadata', async () => {
+      const packageJson = await getRuntimePackageJson(configManager.dirname).catch(() => ({}))
+      const entrypointDetails = await runtimeApiClient.getEntrypointDetails().catch(() => null)
+
       return {
         pid: process.pid,
         cwd: process.cwd(),
+        argv: process.argv,
+        uptimeSeconds: Math.floor(process.uptime()),
         execPath: process.execPath,
         nodeVersion: process.version,
+        projectDir: configManager.dirname,
+        packageName: packageJson.name ?? null,
+        packageVersion: packageJson.version ?? null,
+        url: entrypointDetails?.url ?? null,
         platformaticVersion
       }
     })
 
-    app.get('/services', async () => {
-      return runtimeApiClient.getServices()
+    app.get('/config', async () => {
+      return configManager.current
     })
 
-    app.post('/services/start', async () => {
-      app.log.debug('start services')
-      await runtimeApiClient.start()
+    app.get('/env', async () => {
+      return process.env
     })
 
-    app.post('/services/stop', async () => {
+    app.post('/stop', async () => {
       app.log.debug('stop services')
-      await runtimeApiClient.stop()
+      await runtimeApiClient.close()
     })
 
-    app.post('/services/restart', async () => {
-      app.log.debug('restart services')
+    app.post('/reload', async () => {
+      app.log.debug('reload services')
       await runtimeApiClient.restart()
     })
 
+    app.get('/services', async () => {
+      return runtimeApiClient.getServices()
+    })
+
     app.get('/services/:id', async (request) => {
       const { id } = request.params
       app.log.debug('get service details', { id })
@@ -87,27 +127,85 @@ async function createManagementApi (config, runtimeApiClient) {
         .headers(res.headers)
         .send(res.body)
     })
+
+    app.get('/logs', { websocket: true }, async (connection, req) => {
+      const logLevel = req.query.level || 'info'
+      const pretty = req.query.pretty !== 'false'
+      const serviceId = req.query.serviceId || null
+
+      const logLevelNumber = pinoLogLevels[logLevel]
+      const prettify = prettyFactory()
+
+      const handler = (message) => {
+        for (let log of message.logs) {
+          try {
+            const parsedLog = JSON.parse(log)
+            if (parsedLog.level < logLevelNumber) continue
+            if (serviceId && parsedLog.name !== serviceId) continue
+            if (pretty) {
+              log = prettify(parsedLog)
+            }
+            connection.socket.send(log)
+          } catch (err) {
+            console.error('Failed to parse log message: ', log, err)
+          }
+        }
+      }
+
+      loggingPort.on('message', handler)
+      connection.socket.on('close', () => {
+        loggingPort.off('message', handler)
+      })
+      connection.socket.on('error', () => {
+        loggingPort.off('message', handler)
+      })
+      connection.socket.on('end', () => {
+        loggingPort.off('message', handler)
+      })
+    })
   }, { prefix: '/api' })
 
   return app
 }
 
-function addManagementApiLogger (config) {
-  let logger = config.logger
-  if (!logger) {
-    config.logger = {
-      level: 'info',
-      name: 'management-api'
-    }
-    logger = config.logger
+async function startManagementApi (configManager, runtimeApiClient, loggingPort) {
+  const runtimePID = process.pid
+
+  let socketPath = null
+  if (platform() === 'win32') {
+    socketPath = '\\\\.\\pipe\\platformatic-' + runtimePID
+  } else {
+    await mkdir(PLATFORMATIC_TMP_DIR, { recursive: true })
+    socketPath = join(PLATFORMATIC_TMP_DIR, `${runtimePID}.sock`)
   }
 
-  /* c8 ignore next 5 */
-  if (isatty(1) && !logger.transport) {
-    logger.transport = {
-      target: 'pino-pretty'
+  try {
+    await mkdir(PLATFORMATIC_TMP_DIR, { recursive: true })
+    await unlink(socketPath).catch((err) => {
+      if (err.code !== 'ENOENT') {
+        throw new errors.FailedToUnlinkManagementApiSocket(err.message)
+      }
+    })
+
+    const managementApi = await createManagementApi(
+      configManager,
+      runtimeApiClient,
+      loggingPort
+    )
+
+    if (platform() !== 'win32') {
+      managementApi.addHook('onClose', async () => {
+        await unlink(socketPath).catch(() => {})
+      })
     }
+
+    await managementApi.listen({ path: socketPath })
+    return managementApi
+  /* c8 ignore next 4 */
+  } catch (err) {
+    console.error(err)
+    process.exit(1)
   }
 }
 
-module.exports = { createManagementApi }
+module.exports = { startManagementApi, createManagementApi }

package/lib/start.js

@@ -1,17 +1,16 @@
 'use strict'
 
-const { tmpdir, platform } = require('node:os')
 const { once } = require('node:events')
 const inspector = require('node:inspector')
 const { join, resolve, dirname } = require('node:path')
-const { writeFile, unlink, mkdir } = require('node:fs/promises')
+const { writeFile } = require('node:fs/promises')
 const { pathToFileURL } = require('node:url')
 const { Worker } = require('node:worker_threads')
 const { start: serviceStart } = require('@platformatic/service')
 const { printConfigValidationErrors } = require('@platformatic/config')
 const closeWithGrace = require('close-with-grace')
 const { loadConfig } = require('./load-config')
-const { createManagementApi } = require('./management-api')
+const { startManagementApi } = require('./management-api')
 const { parseInspectorOptions, wrapConfigInRuntimeConfig } = require('./config')
 const RuntimeApiClient = require('./api-client.js')
 const errors = require('./errors')
@@ -25,8 +24,6 @@ const kWorkerExecArgv = [
   kLoaderFile
 ]
 
-const PLATFORMATIC_TMP_DIR = join(tmpdir(), 'platformatic', 'pids')
-
 async function startWithConfig (configManager, env = process.env) {
   const config = configManager.current
 
@@ -47,10 +44,21 @@ async function startWithConfig (configManager, env = process.env) {
   // The configManager cannot be transferred to the worker, so remove it.
   delete config.configManager
 
+  let mainLoggingPort = null
+  let childLoggingPort = config.loggingPort
+
+  if (!childLoggingPort && config.managementApi) {
+    const { port1, port2 } = new MessageChannel()
+    mainLoggingPort = port1
+    childLoggingPort = port2
+
+    config.loggingPort = childLoggingPort
+  }
+
   const worker = new Worker(kWorkerFile, {
     /* c8 ignore next */
     execArgv: config.hotReload ? kWorkerExecArgv : [],
-    transferList: config.loggingPort ? [config.loggingPort] : [],
+    transferList: childLoggingPort ? [childLoggingPort] : [],
     workerData: { config, dirname },
     env
   })
@@ -106,7 +114,11 @@ async function startWithConfig (configManager, env = process.env) {
   const runtimeApiClient = new RuntimeApiClient(worker)
 
   if (config.managementApi) {
-    managementApi = await startManagementApi(config.managementApi, runtimeApiClient)
+    managementApi = await startManagementApi(
+      configManager,
+      runtimeApiClient,
+      mainLoggingPort
+    )
     runtimeApiClient.managementApi = managementApi
   }
 
@@ -126,38 +138,6 @@ async function start (args) {
   return serviceStart(config.app, args)
 }
 
-async function startManagementApi (managementApiConfig, runtimeApiClient) {
-  const runtimePID = process.pid
-
-  let socketPath = null
-  if (platform() === 'win32') {
-    socketPath = '\\\\.\\pipe\\' + join(PLATFORMATIC_TMP_DIR, `${runtimePID}.sock`)
-  } else {
-    await mkdir(PLATFORMATIC_TMP_DIR, { recursive: true })
-    socketPath = join(PLATFORMATIC_TMP_DIR, `${runtimePID}.sock`)
-  }
-
-  try {
-    await mkdir(PLATFORMATIC_TMP_DIR, { recursive: true })
-    await unlink(socketPath).catch((err) => {
-      if (err.code !== 'ENOENT') {
-        throw new errors.FailedToUnlinkManagementApiSocket(err.message)
-      }
-    })
-
-    const managementApi = await createManagementApi(
-      managementApiConfig,
-      runtimeApiClient
-    )
-    await managementApi.listen({ path: socketPath })
-    return managementApi
-  /* c8 ignore next 4 */
-  } catch (err) {
-    console.error(err)
-    process.exit(1)
-  }
-}
-
 async function startCommand (args) {
   try {
     const config = await loadConfig({}, args)

package/lib/worker.js

@@ -12,6 +12,7 @@ const {
 } = require('node:worker_threads')
 const undici = require('undici')
 const pino = require('pino')
+const pretty = require('pino-pretty')
 const { setGlobalDispatcher, Agent } = require('undici')
 const RuntimeApi = require('./api')
 const { MessagePortWritable } = require('./message-port-writable')
@@ -34,7 +35,6 @@ globalThis.fetch = undici.fetch
 const config = workerData.config
 
 let loggerConfig = config.server?.logger
-let destination
 
 if (loggerConfig) {
   loggerConfig = { ...loggerConfig }
@@ -42,21 +42,23 @@ if (loggerConfig) {
   loggerConfig = {}
 }
 
-/* c8 ignore next 10 */
+const cliStream = isatty(1) ? pretty() : pino.destination(1)
+
+let logger = null
 if (config.loggingPort) {
-  destination = new MessagePortWritable({
+  const portStream = new MessagePortWritable({
     metadata: config.loggingMetadata,
     port: config.loggingPort
   })
-  delete loggerConfig.transport
-} else if (!loggerConfig.transport && isatty(1)) {
-  loggerConfig.transport = {
-    target: 'pino-pretty'
-  }
+  const multiStream = pino.multistream([
+    { stream: portStream, level: 'trace' },
+    { stream: cliStream, level: loggerConfig.level || 'info' }
+  ])
+  logger = pino({ level: 'trace' }, multiStream)
+} else {
+  logger = pino(loggerConfig, cliStream)
 }
 
-const logger = pino(loggerConfig, destination)
-
 if (config.server) {
   config.server.logger = logger
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "1.23.0",
+  "version": "1.24.0",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -18,6 +18,7 @@
   "homepage": "https://github.com/platformatic/platformatic#readme",
   "devDependencies": {
     "@fastify/express": "^2.3.0",
+    "@matteo.collina/tspl": "^0.1.1",
     "borp": "^0.9.0",
     "c8": "^9.1.0",
     "execa": "^8.0.1",
@@ -30,11 +31,13 @@
     "tsd": "^0.30.4",
     "typescript": "^5.3.3",
     "undici-oauth-interceptor": "^0.4.2",
-    "@platformatic/sql-graphql": "1.23.0",
-    "@platformatic/sql-mapper": "1.23.0"
+    "ws": "^8.16.0",
+    "@platformatic/sql-graphql": "1.24.0",
+    "@platformatic/sql-mapper": "1.24.0"
   },
   "dependencies": {
     "@fastify/error": "^3.4.1",
+    "@fastify/websocket": "^9.0.0",
     "@hapi/topo": "^6.0.2",
     "boring-name-generator": "^1.0.3",
     "close-with-grace": "^1.2.0",
@@ -52,13 +55,13 @@
     "pino-pretty": "^10.3.1",
     "undici": "^6.6.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/composer": "1.23.0",
-    "@platformatic/config": "1.23.0",
-    "@platformatic/db": "1.23.0",
-    "@platformatic/service": "1.23.0",
-    "@platformatic/generators": "1.23.0",
-    "@platformatic/telemetry": "1.23.0",
-    "@platformatic/utils": "1.23.0"
+    "@platformatic/composer": "1.24.0",
+    "@platformatic/config": "1.24.0",
+    "@platformatic/db": "1.24.0",
+    "@platformatic/generators": "1.24.0",
+    "@platformatic/service": "1.24.0",
+    "@platformatic/telemetry": "1.24.0",
+    "@platformatic/utils": "1.24.0"
   },
   "standard": {
     "ignore": [

package/runtime.mjs

@@ -45,5 +45,5 @@ export async function run (argv) {
 }
 
 if (isMain(import.meta)) {
-  await run(process.argv.splice(2))
+  await run(process.argv.slice(2))
 }