@platformatic/runtime 3.14.0 → 3.16.0

package/config.d.ts

@@ -20,6 +20,7 @@ export type PlatformaticRuntimeConfig = {
         id: string;
         config?: string;
         useHttp?: boolean;
+        reuseTcpPorts?: boolean;
         workers?:
           | number
           | string
@@ -182,6 +183,7 @@ export type PlatformaticRuntimeConfig = {
       rejectUnauthorized?: boolean;
     };
   };
+  reuseTcpPorts?: boolean;
   startTimeout?: number;
   restartOnError?: boolean | number;
   exitOnUnhandledErrors?: boolean;

package/index.js

@@ -127,6 +127,7 @@ export async function loadApplicationsCommands () {
 }
 
 export async function create (configOrRoot, sourceOrConfig, context) {
+  const setupSignals = context?.setupSignals ?? true
   const config = await loadConfiguration(configOrRoot, sourceOrConfig, context)
 
   if (inspector.url() && !config[kMetadata].env.VSCODE_INSPECTOR_OPTIONS) {
@@ -134,12 +135,20 @@ export async function create (configOrRoot, sourceOrConfig, context) {
   }
 
   let runtime = new Runtime(config, context)
-  handleSignal(runtime, config)
+  if (setupSignals) {
+    handleSignal(runtime, config)
+  }
 
   // Handle port handling
   if (context?.start) {
     let port = config.server?.port
 
+    await runtime.init()
+
+    if (context.reloaded) {
+      runtime.logger.info('The application has been successfully reloaded.')
+    }
+
     while (true) {
       try {
         await runtime.start()
@@ -160,7 +169,9 @@ export async function create (configOrRoot, sourceOrConfig, context) {
 
         config.server.port = ++port
         runtime = new Runtime(config, context)
-        handleSignal(runtime, config)
+        if (setupSignals) {
+          handleSignal(runtime, config)
+        }
       }
     }
   }

package/lib/logger.js

@@ -5,19 +5,150 @@ import pretty from 'pino-pretty'
 
 export { abstractLogger } from '@platformatic/foundation'
 
-const customPrettifiers = {
-  name (name, _, obj) {
-    if (typeof obj.worker !== 'undefined') {
-      name += ':' + obj.worker
-      obj.worker = undefined // Do not show the worker in a separate line
-    }
+// A valid color in the ANSI 256 color palette - Adiacent colors are purposely different
+const colors = [
+  196, // bright red
+  46, // bright green
+  33, // light blue
+  226, // bright yellow
+  201, // bright magenta
+  51, // cyan
+  208, // orange
+  118, // lime
+  39, // deep sky blue
+  220, // gold
+  129, // violet
+  82, // spring green
+  33, // blue
+  214, // amber
+  99, // orchid
+  190, // light yellow-green
+  45, // turquoise
+  197, // rose
+  50, // aqua
+  202, // orange-red
+  141, // lavender
+  154, // pale green
+  93, // pink
+  33, // light blue again (for spacing)
+  220, // gold
+  201, // magenta
+  46, // green
+  27, // navy blue
+  214, // amber
+  99, // orchid
+  190, // light yellow-green
+  39, // cyan-blue
+  200, // violet
+  82, // neon green
+  208, // orange
+  135, // purple
+  118, // lime
+  33, // bright blue
+  220, // gold
+  201, // bright magenta
+  46, // bright green
+  21, // bright blue
+  202, // orange-red
+  141, // purple
+  118, // spring green
+  208, // orange
+  93, // pink
+  190, // yellow-green
+  39, // cyan
+  196, // bright red
+  226 // bright yellow
+]
+
+function createLoggerContext () {
+  const context = {
+    colors: {},
+    maxLength: 0,
+    updatePrefixes (ids) {
+      context.colors = {}
+      context.maxLength = 0
+
+      for (const id of ids) {
+        context.maxLength = Math.max(context.maxLength, id.length)
+        let hash = 0
+
+        if (!pretty.isColorSupported && process.env.FORCE_COLOR !== 'true') {
+          context.colors[id] = ''
+          continue
+        }
+
+        // Calculate the hash of the id to pick a color
+        for (const char of id) {
+          for (let i = 0; i < char.length; i++) {
+            hash = ((hash << 5) - hash) ^ char.charCodeAt(i)
+            hash = Math.abs(hash) % Number.MAX_SAFE_INTEGER
+          }
+        }
 
-    return name
+        context.colors[id] = `\u001B[38;5;${colors[hash % colors.length]}m`
+      }
+    }
   }
+
+  return context
+}
+
+function createPrettifier (context) {
+  return pretty({
+    messageFormat (log, key) {
+      const { name, pid, hostname, caller, worker } = log
+
+      context.current = {
+        name,
+        pid,
+        hostname,
+        caller,
+        worker
+      }
+
+      let prefix = ''
+      let color = ''
+
+      if (name) {
+        prefix = name.match(/:\d+$/) ? name : `${name}:${worker}`
+        color = context.colors[prefix] ?? ''
+      }
+
+      context.current.prefix = `(${pid}) ` + prefix.padStart(context.maxLength, ' ')
+      context.current.color = color
+
+      // We need to nullify all these so that prettifierMetadata in pino-pretty returns an empty string
+      log.name = undefined
+      log.pid = undefined
+      log.hostname = undefined
+      log.caller = undefined
+      log.worker = undefined
+
+      return log[key]
+    },
+    customPrettifiers: {
+      time (time) {
+        return `${context.current.color}[${time}]`
+      },
+      level (_u1, _u2, _u3, { label, labelColorized }) {
+        // No applications registered yet, no need to pad
+        if (context.maxLength === 0) {
+          return context.current.prefix + labelColorized
+        }
+
+        const current = context.current
+        const level = current.caller ? current.caller : labelColorized.replace(label, label.padStart(6, ' '))
+
+        return `${current.prefix} | \u001B[0m ${level}`
+      }
+    }
+  })
 }
 
 // Create the runtime logger
 export async function createLogger (config) {
+  const context = createLoggerContext()
+
   const loggerConfig = { ...config.logger, transport: undefined }
   if (config.logger.base === null) {
     loggerConfig.base = undefined
@@ -28,7 +159,7 @@ export async function createLogger (config) {
   if (config.logger.transport) {
     cliStream = pino.transport(config.logger.transport)
   } else if ((process.env.FORCE_TTY || isatty(1)) && usePrettyPrint()) {
-    cliStream = pretty({ customPrettifiers })
+    cliStream = createPrettifier(context)
   } else {
     cliStream = pino.destination(1)
   }
@@ -42,7 +173,7 @@ export async function createLogger (config) {
   }
 
   if (!config.managementApi) {
-    return [pino(loggerConfig, cliStream), cliStream]
+    return [pino(loggerConfig, cliStream), cliStream, context]
   }
 
   const multiStream = pino.multistream([{ stream: cliStream, level: loggerConfig.level }])
@@ -55,5 +186,5 @@ export async function createLogger (config) {
     logsLimitCount = 1
   }
 
-  return [pino(loggerConfig, multiStream), multiStream]
+  return [pino(loggerConfig, multiStream), multiStream, context]
 }

package/lib/management-api.js

@@ -1,11 +1,18 @@
 import fastifyAccepts from '@fastify/accepts'
 import fastifyWebsocket from '@fastify/websocket'
-import { createDirectory, safeRemove } from '@platformatic/foundation'
+import {
+  applications as applicationSchema,
+  createDirectory,
+  kMetadata,
+  safeRemove,
+  validate
+} from '@platformatic/foundation'
 import fastify from 'fastify'
 import { platform, tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { setTimeout as sleep } from 'node:timers/promises'
 import { createWebSocketStream } from 'ws'
+import { prepareApplication } from './config.js'
 
 const PLATFORMATIC_TMP_DIR = join(tmpdir(), 'platformatic', 'runtimes')
 
@@ -14,6 +21,26 @@ export async function managementApiPlugin (app, opts) {
 
   const runtime = opts.runtime
 
+  async function deleteApplications (ids, reply) {
+    const validIds = runtime.getApplicationsIds()
+
+    for (const id of ids) {
+      if (!validIds.includes(id)) {
+        reply.code(404)
+
+        return {
+          error: 'Not Found',
+          message: `Application with id "${id}" not found.`,
+          statusCode: 404
+        }
+      }
+    }
+
+    const removed = await runtime.removeApplications(ids)
+    reply.code(202)
+    return removed
+  }
+
   app.get('/status', async () => {
     const status = runtime.getRuntimeStatus()
     return { status }
@@ -23,8 +50,16 @@ export async function managementApiPlugin (app, opts) {
     return runtime.getRuntimeMetadata()
   })
 
-  app.get('/config', async () => {
-    return runtime.getRuntimeConfig()
+  app.get('/config', async request => {
+    const metadata = request.query.metadata === 'true'
+    const rawConfig = await runtime.getRuntimeConfig(metadata)
+
+    if (metadata) {
+      const { [kMetadata]: __metadata, ...config } = rawConfig
+      return { ...config, __metadata }
+    }
+
+    return rawConfig
   })
 
   app.get('/env', async () => {
@@ -46,12 +81,60 @@ export async function managementApiPlugin (app, opts) {
     return runtime.getApplications()
   })
 
+  app.post('/applications', async (request, reply) => {
+    let applications = request.body
+
+    if (!Array.isArray(applications)) {
+      applications = [applications]
+    }
+
+    const config = runtime.getRuntimeConfig(true)
+
+    try {
+      validate(applicationSchema, applications, {}, true, config[kMetadata].root)
+    } catch (err) {
+      reply.code(400)
+
+      return {
+        statusCode: 400,
+        error: 'Bad Request',
+        message: 'Invalid applications configuration.',
+        validationErrors: err.validationErrors
+      }
+    }
+
+    for (let i = 0; i < applications.length; i++) {
+      applications[i] = await prepareApplication(config, applications[i])
+    }
+
+    const created = await runtime.addApplications(applications, request.query.start !== 'false')
+    reply.code(201)
+    return created
+  })
+
+  app.delete('/applications', async (request, reply) => {
+    if (!Array.isArray(request.body)) {
+      reply.code(404)
+      return {
+        statusCode: 404,
+        error: 'Bad Request',
+        message: 'Invalid applications IDs.'
+      }
+    }
+
+    return deleteApplications(request.body, reply)
+  })
+
   app.get('/applications/:id', async request => {
     const { id } = request.params
     app.log.debug('get application details', { id })
     return runtime.getApplicationDetails(id)
   })
 
+  app.delete('/applications/:id', async (request, reply) => {
+    return deleteApplications([request.params.id], reply)
+  })
+
   app.get('/applications/:id/config', async request => {
     const { id } = request.params
     app.log.debug('get application config', { id })
@@ -195,7 +278,7 @@ export async function managementApiPlugin (app, opts) {
     })
   })
 
-  app.get('/logs/live', { websocket: true }, async (socket, req) => {
+  app.get('/logs/live', { websocket: true }, async socket => {
     runtime.addLoggerDestination(createWebSocketStream(socket))
   })
 }

package/lib/runtime.js

@@ -47,9 +47,9 @@ import { startPrometheusServer } from './prom-server.js'
 import { startScheduler } from './scheduler.js'
 import { createSharedStore } from './shared-http-cache.js'
 import { version } from './version.js'
+import { HealthSignalsQueue } from './worker/health-signals.js'
 import { sendViaITC, waitEventFromITC } from './worker/itc.js'
 import { RoundRobinMap } from './worker/round-robin-map.js'
-import { HealthSignalsQueue } from './worker/health-signals.js'
 import {
   kApplicationId,
   kConfig,
@@ -60,11 +60,11 @@ import {
   kITC,
   kLastHealthCheckELU,
   kStderrMarker,
+  kWorkerHealthSignals,
   kWorkerId,
   kWorkersBroadcast,
   kWorkerStartTime,
-  kWorkerStatus,
-  kWorkerHealthSignals
+  kWorkerStatus
 } from './worker/symbols.js'
 
 const kWorkerFile = join(import.meta.dirname, 'worker/main.js')
@@ -84,6 +84,7 @@ export class Runtime extends EventEmitter {
   error
 
   #loggerDestination
+  #loggerContext
   #stdio
 
   #status // starting, started, stopping, stopped, closed
@@ -201,9 +202,10 @@ export class Runtime extends EventEmitter {
     }
 
     // Create the logger
-    const [logger, destination] = await createLogger(config)
+    const [logger, destination, context] = await createLogger(config)
     this.logger = logger
     this.#loggerDestination = destination
+    this.#loggerContext = context
 
     this.#createWorkersBroadcastChannel()
 
@@ -358,6 +360,7 @@ export class Runtime extends EventEmitter {
 
       this.logger = abstractLogger
       this.#loggerDestination = null
+      this.#loggerContext = null
     }
 
     this.#updateStatus('closed')
@@ -466,12 +469,21 @@ export class Runtime extends EventEmitter {
     await executeInParallel(this.#setupApplication.bind(this), setupInvocations, this.#concurrency)
 
     for (const application of applications) {
+      this.logger.info(`Added application "${application.id}"${application.entrypoint ? ' (entrypoint)' : ''}.`)
       this.emitAndNotify('application:added', application)
     }
 
     if (start) {
       await this.startApplications(toStart)
     }
+
+    const created = []
+    for (const { id } of applications) {
+      created.push(await this.getApplicationDetails(id))
+    }
+
+    this.#updateLoggingPrefixes()
+    return created
   }
 
   async removeApplications (applications, silent = false) {
@@ -479,6 +491,13 @@ export class Runtime extends EventEmitter {
       throw new CannotRemoveEntrypointError()
     }
 
+    const removed = []
+    for (const application of applications) {
+      const details = await this.getApplicationDetails(application)
+      details.status = 'removed'
+      removed.push(details)
+    }
+
     await this.stopApplications(applications, silent, true)
 
     for (const application of applications) {
@@ -487,8 +506,12 @@ export class Runtime extends EventEmitter {
     }
 
     for (const application of applications) {
+      this.logger.info(`Removed application "${application}".`)
       this.emitAndNotify('application:removed', application)
     }
+
+    this.#updateLoggingPrefixes()
+    return removed
   }
 
   async startApplications (applicationsToStart, silent = false) {
@@ -1182,7 +1205,7 @@ export class Runtime extends EventEmitter {
       throw e
     }
 
-    const { entrypoint, localUrl } = application[kConfig]
+    const { entrypoint, localUrl, config, path } = application[kConfig]
 
     const status = await sendViaITC(application, 'getStatus')
     const { type, version, dependencies } = await sendViaITC(application, 'getApplicationInfo')
@@ -1190,6 +1213,8 @@ export class Runtime extends EventEmitter {
     const applicationDetails = {
       id,
       type,
+      config,
+      path,
       status,
       dependencies,
       version,
@@ -1587,7 +1612,7 @@ export class Runtime extends EventEmitter {
             await this.startApplication(applicationId)
           }
 
-          this.logger.info(`The application "${applicationId}" has been successfully reloaded ...`)
+          this.logger.info(`The application "${applicationId}" has been successfully reloaded.`)
           this.emitAndNotify('application:worker:reloaded', eventPayload)
 
           if (applicationConfig.entrypoint) {
@@ -1666,13 +1691,7 @@ export class Runtime extends EventEmitter {
 
     const healthConfig = worker[kConfig].health
 
-    let {
-      maxELU,
-      maxHeapUsed,
-      maxHeapTotal,
-      maxUnhealthyChecks,
-      interval
-    } = worker[kConfig].health
+    let { maxELU, maxHeapUsed, maxHeapTotal, maxUnhealthyChecks, interval } = worker[kConfig].health
 
     if (typeof maxHeapTotal === 'string') {
       maxHeapTotal = parseMemorySize(maxHeapTotal)
@@ -1682,7 +1701,7 @@ export class Runtime extends EventEmitter {
       interval = 1000
       this.logger.warn(
         `The health check interval for the "${errorLabel}" is set to ${healthConfig.interval}ms. ` +
-        'The minimum health check interval is 1s. It will be set to 1000ms.'
+          'The minimum health check interval is 1s. It will be set to 1000ms.'
       )
     }
 
@@ -1741,14 +1760,14 @@ export class Runtime extends EventEmitter {
 
             this.logger.error(
               { elu: health.elu, maxELU, memoryUsage: health.heapUsed, maxMemoryUsage: maxHeapUsed },
-            `The ${errorLabel} is unhealthy. Replacing it ...`
+              `The ${errorLabel} is unhealthy. Replacing it ...`
             )
 
             await this.#replaceWorker(config, applicationConfig, workersCount, id, index, worker)
           } catch (e) {
             this.logger.error(
               { elu: health.elu, maxELU, memoryUsage: health.heapUsed, maxMemoryUsage: maxHeapUsed },
-            `Cannot replace the ${errorLabel}. Forcefully terminating it ...`
+              `Cannot replace the ${errorLabel}. Forcefully terminating it ...`
             )
 
             worker.terminate()
@@ -2320,6 +2339,8 @@ export class Runtime extends EventEmitter {
         throw result.reason
       }
     }
+
+    this.#updateLoggingPrefixes()
   }
 
   async #updateApplicationConfigHealth (applicationId, health) {
@@ -2694,4 +2715,17 @@ export class Runtime extends EventEmitter {
     worker[kWorkerHealthSignals] ??= new HealthSignalsQueue()
     worker[kWorkerHealthSignals].add(signals)
   }
+
+  #updateLoggingPrefixes () {
+    if (!this.#loggerContext) {
+      return
+    }
+
+    const ids = []
+    for (const worker of this.#workers.values()) {
+      ids.push(`${worker[kFullId]}`)
+    }
+
+    this.#loggerContext.updatePrefixes(ids)
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "3.14.0",
+  "version": "3.16.0",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -35,14 +35,14 @@
     "typescript": "^5.5.4",
     "undici-oidc-interceptor": "^0.5.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/db": "3.14.0",
-    "@platformatic/gateway": "3.14.0",
-    "@platformatic/composer": "3.14.0",
-    "@platformatic/node": "3.14.0",
-    "@platformatic/service": "3.14.0",
-    "@platformatic/sql-graphql": "3.14.0",
-    "@platformatic/sql-mapper": "3.14.0",
-    "@platformatic/wattpm-pprof-capture": "3.14.0"
+    "@platformatic/composer": "3.16.0",
+    "@platformatic/db": "3.16.0",
+    "@platformatic/gateway": "3.16.0",
+    "@platformatic/node": "3.16.0",
+    "@platformatic/sql-mapper": "3.16.0",
+    "@platformatic/sql-graphql": "3.16.0",
+    "@platformatic/wattpm-pprof-capture": "3.16.0",
+    "@platformatic/service": "3.16.0"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
@@ -73,12 +73,12 @@
     "undici": "^7.0.0",
     "undici-thread-interceptor": "^0.15.0",
     "ws": "^8.16.0",
-    "@platformatic/basic": "3.14.0",
-    "@platformatic/metrics": "3.14.0",
-    "@platformatic/foundation": "3.14.0",
-    "@platformatic/generators": "3.14.0",
-    "@platformatic/telemetry": "3.14.0",
-    "@platformatic/itc": "3.14.0"
+    "@platformatic/basic": "3.16.0",
+    "@platformatic/generators": "3.16.0",
+    "@platformatic/itc": "3.16.0",
+    "@platformatic/foundation": "3.16.0",
+    "@platformatic/metrics": "3.16.0",
+    "@platformatic/telemetry": "3.16.0"
   },
   "engines": {
     "node": ">=22.19.0"

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.14.0.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.16.0.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Runtime Config",
   "type": "object",
@@ -64,6 +64,10 @@
               "useHttp": {
                 "type": "boolean"
               },
+              "reuseTcpPorts": {
+                "type": "boolean",
+                "default": true
+              },
               "workers": {
                 "anyOf": [
                   {
@@ -342,6 +346,10 @@
           "useHttp": {
             "type": "boolean"
           },
+          "reuseTcpPorts": {
+            "type": "boolean",
+            "default": true
+          },
           "workers": {
             "anyOf": [
               {
@@ -618,6 +626,10 @@
           "useHttp": {
             "type": "boolean"
           },
+          "reuseTcpPorts": {
+            "type": "boolean",
+            "default": true
+          },
           "workers": {
             "anyOf": [
               {
@@ -894,6 +906,10 @@
           "useHttp": {
             "type": "boolean"
           },
+          "reuseTcpPorts": {
+            "type": "boolean",
+            "default": true
+          },
           "workers": {
             "anyOf": [
               {
@@ -1464,6 +1480,10 @@
       },
       "additionalProperties": false
     },
+    "reuseTcpPorts": {
+      "type": "boolean",
+      "default": true
+    },
     "startTimeout": {
       "default": 30000,
       "type": "number",