@platformatic/runtime 1.27.0 → 1.28.0

package/fixtures/do-not-reload-dependencies/platformatic.service.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://platformatic.dev/schemas/v0.33.1/service",
+  "$schema": "https://platformatic.dev/schemas/v0.27.0/service",
   "server": {
     "hostname": "127.0.0.1",
     "port": "{PORT}",

package/fixtures/interceptors/idp.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const fastify = require('fastify')
+const formBody = require('@fastify/formbody')
 const { createSigner } = require('fast-jwt')
 
 async function start (opts) {
@@ -15,6 +16,8 @@ async function start (opts) {
   app.decorate('refreshToken', '')
   app.decorate('signSync', signSync)
 
+  app.register(formBody)
+
   // Dump bearer token implementation
   app.post('/token', async (req, res) => {
     return { access_token: signSync({}) }

package/fixtures/interceptors/platformatic.runtime.json

@@ -14,8 +14,9 @@
   "undici": {
     "interceptors": {
       "Agent": [{
-        "module": "undici-oauth-interceptor",
+        "module": "undici-oidc-interceptor",
         "options": {
+          "idpTokenUrl": "{{PLT_IDP_TOKEN_URL}}",
           "refreshToken": "{{PLT_REFRESH_TOKEN}}",
           "origins": ["{{PLT_EXTERNAL_SERVICE}}"],
           "clientId": "my-client-id"

package/fixtures/interceptors-2/platformatic.runtime.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://platformatic.dev/schemas/v1.20.0/runtime",
+  "entrypoint": "a",
+  "autoload": {
+    "path": "./services"
+  },
+  "server": {
+    "hostname": "127.0.0.1",
+    "port": "{{PORT}}",
+    "logger": {
+      "level": "info"
+    }
+  },
+  "undici": {
+    "interceptors": [{
+      "module": "undici-oidc-interceptor",
+      "options": {
+        "idpTokenUrl": "{{PLT_IDP_TOKEN_URL}}",
+        "refreshToken": "{{PLT_REFRESH_TOKEN}}",
+        "origins": ["{{PLT_EXTERNAL_SERVICE}}"],
+        "clientId": "my-client-id"
+      }
+    }]
+  }
+}

package/fixtures/interceptors-2/services/a/platformatic.service.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "https://platformatic.dev/schemas/v1.3.0/service",
+  "server": {
+    "logger": {
+      "level": "warn"
+    }
+  },
+  "plugins": {
+    "paths": [{
+      "path": "plugin.js",
+      "encapsulate": false,
+      "options": {
+        "externalService": "{{PLT_EXTERNAL_SERVICE}}"
+      }
+    }]
+  }
+}

package/fixtures/interceptors-2/services/a/plugin.js

@@ -0,0 +1,15 @@
+'use strict'
+
+const { request } = require('undici')
+
+module.exports = async function (fastify, options) {
+  fastify.get('/hello', async (_, reply) => {
+    const res = await request(`${options.externalService}/hello`)
+    if (res.statusCode !== 200) {
+      reply.code(res.statusCode)
+    }
+    reply.log.info('response received')
+    const data = await res.body.json()
+    return data
+  })
+}

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

@@ -5,5 +5,6 @@
   },
   "plugins": {
     "paths": ["plugin.js"]
-  }
+  },
+  "metrics": true
 }

package/lib/api-client.js

@@ -6,10 +6,14 @@ const errors = require('./errors')
 const { setTimeout: sleep } = require('node:timers/promises')
 
 const MAX_LISTENERS_COUNT = 100
+const MAX_METRICS_QUEUE_LENGTH = 5 * 60 // 5 minutes in seconds
+const COLLECT_METRICS_TIMEOUT = 1000
 
 class RuntimeApiClient extends EventEmitter {
   #exitCode
   #exitPromise
+  #metrics
+  #metricsTimeout
 
   constructor (worker) {
     super()
@@ -78,6 +82,10 @@ class RuntimeApiClient extends EventEmitter {
     return this.#sendCommand('plt:get-service-graphql-schema', { id })
   }
 
+  async getMetrics (format = 'json') {
+    return this.#sendCommand('plt:get-metrics', { format })
+  }
+
   async startService (id) {
     return this.#sendCommand('plt:start-service', { id })
   }
@@ -90,6 +98,115 @@ class RuntimeApiClient extends EventEmitter {
     return this.#sendCommand('plt:inject', { id, injectParams })
   }
 
+  getCachedMetrics () {
+    return this.#metrics
+  }
+
+  async getFormattedMetrics () {
+    const { metrics } = await this.getMetrics()
+
+    const entrypointDetails = await this.getEntrypointDetails()
+    const entrypointConfig = await this.getServiceConfig(entrypointDetails.id)
+    const entrypointMetricsPrefix = entrypointConfig.metrics?.prefix
+
+    const cpuMetric = metrics.find(
+      (metric) => metric.name === 'process_cpu_percent_usage'
+    )
+    const rssMetric = metrics.find(
+      (metric) => metric.name === 'process_resident_memory_bytes'
+    )
+    const totalHeapSizeMetric = metrics.find(
+      (metric) => metric.name === 'nodejs_heap_size_total_bytes'
+    )
+    const usedHeapSizeMetric = metrics.find(
+      (metric) => metric.name === 'nodejs_heap_size_used_bytes'
+    )
+    const heapSpaceSizeTotalMetric = metrics.find(
+      (metric) => metric.name === 'nodejs_heap_space_size_total_bytes'
+    )
+    const newSpaceSizeTotalMetric = heapSpaceSizeTotalMetric.values.find(
+      (value) => value.labels.space === 'new'
+    )
+    const oldSpaceSizeTotalMetric = heapSpaceSizeTotalMetric.values.find(
+      (value) => value.labels.space === 'old'
+    )
+    const eventLoopUtilizationMetric = metrics.find(
+      (metric) => metric.name === 'nodejs_eventloop_utilization'
+    )
+
+    let p90Value = 0
+    let p95Value = 0
+    let p99Value = 0
+
+    if (entrypointMetricsPrefix) {
+      const metricName = entrypointMetricsPrefix + 'http_request_all_summary_seconds'
+      const httpLatencyMetrics = metrics.find((metric) => metric.name === metricName)
+
+      p90Value = httpLatencyMetrics.values.find(
+        (value) => value.labels.quantile === 0.9
+      ).value || 0
+      p95Value = httpLatencyMetrics.values.find(
+        (value) => value.labels.quantile === 0.95
+      ).value || 0
+      p99Value = httpLatencyMetrics.values.find(
+        (value) => value.labels.quantile === 0.99
+      ).value || 0
+
+      p90Value = Math.round(p90Value * 1000)
+      p95Value = Math.round(p95Value * 1000)
+      p99Value = Math.round(p99Value * 1000)
+    }
+
+    const cpu = cpuMetric.values[0].value
+    const rss = rssMetric.values[0].value
+    const elu = eventLoopUtilizationMetric.values[0].value
+    const totalHeapSize = totalHeapSizeMetric.values[0].value
+    const usedHeapSize = usedHeapSizeMetric.values[0].value
+    const newSpaceSize = newSpaceSizeTotalMetric.value
+    const oldSpaceSize = oldSpaceSizeTotalMetric.value
+
+    const formattedMetrics = {
+      version: 1,
+      date: new Date().toISOString(),
+      cpu,
+      elu,
+      rss,
+      totalHeapSize,
+      usedHeapSize,
+      newSpaceSize,
+      oldSpaceSize,
+      entrypoint: {
+        latency: {
+          p90: p90Value,
+          p95: p95Value,
+          p99: p99Value
+        }
+      }
+    }
+    return formattedMetrics
+  }
+
+  startCollectingMetrics () {
+    this.#metrics = []
+    this.#metricsTimeout = setInterval(async () => {
+      let metrics = null
+      try {
+        metrics = await this.getFormattedMetrics()
+      } catch (error) {
+        if (!(error instanceof errors.RuntimeExitedError)) {
+          console.error('Error collecting metrics', error)
+        }
+        return
+      }
+
+      this.emit('metrics', metrics)
+      this.#metrics.push(metrics)
+      if (this.#metrics.length > MAX_METRICS_QUEUE_LENGTH) {
+        this.#metrics.shift()
+      }
+    }, COLLECT_METRICS_TIMEOUT).unref()
+  }
+
   async #sendCommand (command, params = {}) {
     const operationId = randomUUID()
 
@@ -113,6 +230,7 @@ class RuntimeApiClient extends EventEmitter {
   async #exitHandler () {
     this.#exitCode = undefined
     return once(this.worker, 'exit').then((msg) => {
+      clearInterval(this.#metricsTimeout)
       this.#exitCode = msg[0]
       return msg
     })

package/lib/api.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { getGlobalDispatcher, setGlobalDispatcher } = require('undici')
-const FastifyUndiciDispatcher = require('fastify-undici-dispatcher')
+const { createFastifyInterceptor } = require('fastify-undici-dispatcher')
 const { PlatformaticApp } = require('./app')
 const errors = require('./errors')
 const { printSchema } = require('graphql')
@@ -9,9 +9,10 @@ const { printSchema } = require('graphql')
 class RuntimeApi {
   #services
   #dispatcher
+  #interceptor
   #logger
 
-  constructor (config, logger, loaderPort) {
+  constructor (config, logger, loaderPort, composedInterceptors = []) {
     this.#services = new Map()
     this.#logger = logger
     const telemetryConfig = config.telemetry
@@ -37,11 +38,14 @@ class RuntimeApi {
       this.#services.set(service.id, app)
     }
 
-    this.#dispatcher = new FastifyUndiciDispatcher({
-      dispatcher: getGlobalDispatcher(),
+    this.#interceptor = createFastifyInterceptor({
       // setting the domain here allows for fail-fast scenarios
       domain: '.plt.local'
     })
+
+    composedInterceptors.unshift(this.#interceptor)
+
+    this.#dispatcher = getGlobalDispatcher().compose(composedInterceptors)
     setGlobalDispatcher(this.#dispatcher)
   }
 
@@ -122,6 +126,8 @@ class RuntimeApi {
         return this.#getServiceOpenapiSchema(params)
       case 'plt:get-service-graphql-schema':
         return this.#getServiceGraphqlSchema(params)
+      case 'plt:get-metrics':
+        return this.#getMetrics(params)
       case 'plt:start-service':
         return this.#startService(params)
       case 'plt:stop-service':
@@ -144,7 +150,7 @@ class RuntimeApi {
       }
 
       const serviceUrl = new URL(service.appConfig.localUrl)
-      this.#dispatcher.route(serviceUrl.host, service.server)
+      this.#interceptor.route(serviceUrl.host, service.server)
     }
     return entrypointUrl
   }
@@ -172,7 +178,7 @@ class RuntimeApi {
       }
 
       const serviceUrl = new URL(service.appConfig.localUrl)
-      this.#dispatcher.route(serviceUrl.host, service.server)
+      this.#interceptor.route(serviceUrl.host, service.server)
     }
     return entrypointUrl
   }
@@ -277,6 +283,33 @@ class RuntimeApi {
     }
   }
 
+  async #getMetrics ({ format }) {
+    let entrypoint = null
+    for (const service of this.#services.values()) {
+      if (service.appConfig.entrypoint) {
+        entrypoint = service
+        break
+      }
+    }
+
+    if (!entrypoint.config) {
+      throw new errors.ServiceNotStartedError(entrypoint.id)
+    }
+
+    const promRegister = entrypoint.server.metrics?.client?.register
+    if (!promRegister) {
+      return null
+    }
+
+    // All runtime services shares the same metrics registry.
+    // Getting metrics from the entrypoint returns all metrics.
+    const metrics = format === 'json'
+      ? await promRegister.getMetricsAsJSON()
+      : await promRegister.metrics()
+
+    return { metrics }
+  }
+
   async #startService ({ id }) {
     const service = this.#getServiceById(id)
     await service.start()

package/lib/app.js

@@ -4,6 +4,7 @@ const { once } = require('node:events')
 const { dirname } = require('node:path')
 const { FileWatcher } = require('@platformatic/utils')
 const debounce = require('debounce')
+const { snakeCase } = require('change-case-all')
 const { buildServer } = require('./build-server')
 const { loadConfig } = require('./load-config')
 const errors = require('./errors')
@@ -106,6 +107,15 @@ class PlatformaticApp {
       })
     }
 
+    configManager.update({
+      ...configManager.current,
+      metrics: {
+        ...configManager.current.metrics,
+        defaultMetrics: { enabled: this.appConfig.entrypoint },
+        prefix: snakeCase(this.appConfig.id) + '_'
+      }
+    })
+
     if (!this.appConfig.entrypoint) {
       configManager.update({
         ...configManager.current,
@@ -205,7 +215,7 @@ class PlatformaticApp {
         onMissingEnv (key) {
           return appConfig.localServiceEnvVars.get(key)
         }
-      })
+      }, true, this.#logger)
     } catch (err) {
       this.#logAndExit(err)
     }

package/lib/config.js

@@ -6,6 +6,7 @@ const Topo = require('@hapi/topo')
 const ConfigManager = require('@platformatic/config')
 const { schema } = require('./schema')
 const errors = require('./errors')
+const upgrade = require('./upgrade')
 
 async function _transformConfig (configManager) {
   const config = configManager.current
@@ -245,6 +246,7 @@ platformaticRuntime[Symbol.for('skip-override')] = true
 platformaticRuntime.schema = schema
 platformaticRuntime.configType = 'runtime'
 platformaticRuntime.configManagerConfig = {
+  version: require('../package.json').version,
   schema,
   allowToWatch: ['.env'],
   schemaOptions: {
@@ -256,7 +258,8 @@ platformaticRuntime.configManagerConfig = {
   envWhitelist: ['DATABASE_URL', 'PORT', 'HOSTNAME'],
   async transformConfig () {
     await _transformConfig(this)
-  }
+  },
+  upgrade
 }
 
 async function wrapConfigInRuntimeConfig ({ configManager, args }) {

package/lib/errors.js

@@ -22,5 +22,6 @@ module.exports = {
   InspectorHostError: createError(`${ERROR_PREFIX}_INSPECTOR_HOST`, 'Inspector host cannot be empty'),
   CannotMapSpecifierToAbsolutePathError: createError(`${ERROR_PREFIX}_CANNOT_MAP_SPECIFIER_TO_ABSOLUTE_PATH`, 'Cannot map "%s" to an absolute path'),
   NodeInspectorFlagsNotSupportedError: createError(`${ERROR_PREFIX}_NODE_INSPECTOR_FLAGS_NOT_SUPPORTED`, 'The Node.js inspector flags are not supported. Please use \'platformatic start --inspect\' instead.'),
-  FailedToUnlinkManagementApiSocket: createError(`${ERROR_PREFIX}_FAILED_TO_UNLINK_MANAGEMENT_API_SOCKET`, 'Failed to unlink management API socket "%s"')
+  FailedToUnlinkManagementApiSocket: createError(`${ERROR_PREFIX}_FAILED_TO_UNLINK_MANAGEMENT_API_SOCKET`, 'Failed to unlink management API socket "%s"'),
+  LogFileNotFound: createError(`${ERROR_PREFIX}_LOG_FILE_NOT_FOUND`, 'Log file with index %s not found', 404)
 }

package/lib/generator/runtime-generator.js

@@ -54,11 +54,11 @@ class RuntimeGenerator extends BaseGenerator {
     const template = {
       name: `${this.runtimeName}`,
       scripts: {
-        start: 'platformatic start',
-        test: 'node --test test/*/*.test.js'
+        start: 'platformatic start'
       },
       devDependencies: {
-        fastify: `^${this.fastifyVersion}`
+        fastify: `^${this.fastifyVersion}`,
+        borp: `${this.pkgData.devDependencies.borp}`
       },
       dependencies: {
         platformatic: `^${this.platformaticVersion}`,

package/lib/interceptors.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const { pathToFileURL } = require('node:url')
+
+async function loadInterceptor (_require, module, options) {
+  const url = pathToFileURL(_require.resolve(module))
+  const interceptor = (await import(url)).default
+  return interceptor(options)
+}
+
+function loadInterceptors (_require, interceptors) {
+  return Promise.all(interceptors.map(async ({ module, options }) => {
+    return loadInterceptor(_require, module, options)
+  }))
+}
+
+module.exports = loadInterceptors

package/lib/logs.js

@@ -0,0 +1,112 @@
+'use strict'
+
+const { tmpdir } = require('node:os')
+const { join } = require('node:path')
+const { createReadStream, watch } = require('node:fs')
+const { readdir } = require('node:fs/promises')
+const ts = require('tail-file-stream')
+
+const PLATFORMATIC_TMP_DIR = join(tmpdir(), 'platformatic', 'runtimes')
+const runtimeTmpDir = join(PLATFORMATIC_TMP_DIR, process.pid.toString())
+
+async function getLogFiles () {
+  const runtimeTmpFiles = await readdir(runtimeTmpDir)
+  const runtimeLogFiles = runtimeTmpFiles
+    .filter((file) => file.startsWith('logs'))
+    .sort((log1, log2) => {
+      const index1 = parseInt(log1.slice('logs.'.length))
+      const index2 = parseInt(log2.slice('logs.'.length))
+      return index1 - index2
+    })
+  return runtimeLogFiles
+}
+
+async function pipeLiveLogs (writableStream, logger, startLogIndex) {
+  const runtimeLogFiles = await getLogFiles()
+  if (runtimeLogFiles.length === 0) {
+    writableStream.end()
+    return
+  }
+
+  let latestFileIndex = parseInt(runtimeLogFiles.at(-1).slice('logs.'.length))
+
+  let waiting = false
+  let fileStream = null
+  let fileIndex = startLogIndex ?? latestFileIndex
+
+  const watcher = watch(runtimeTmpDir, async (event, filename) => {
+    if (event === 'rename' && filename.startsWith('logs')) {
+      const logFileIndex = parseInt(filename.slice('logs.'.length))
+      if (logFileIndex > latestFileIndex) {
+        latestFileIndex = logFileIndex
+        if (waiting) {
+          streamLogFile(++fileIndex)
+        }
+      }
+    }
+  }).unref()
+
+  const streamLogFile = () => {
+    const fileName = 'logs.' + fileIndex
+    const filePath = join(runtimeTmpDir, fileName)
+
+    const prevFileStream = fileStream
+
+    fileStream = ts.createReadStream(filePath)
+    fileStream.pipe(writableStream, { end: false })
+
+    if (prevFileStream) {
+      prevFileStream.unpipe(writableStream)
+      prevFileStream.destroy()
+    }
+
+    fileStream.on('error', (err) => {
+      logger.log.error(err, 'Error streaming log file')
+      fileStream.destroy()
+      watcher.close()
+      writableStream.end()
+    })
+
+    fileStream.on('data', () => {
+      waiting = false
+    })
+
+    fileStream.on('eof', () => {
+      if (latestFileIndex > fileIndex) {
+        streamLogFile(++fileIndex)
+      } else {
+        waiting = true
+      }
+    })
+
+    return fileStream
+  }
+
+  streamLogFile(fileIndex)
+
+  writableStream.on('close', () => {
+    watcher.close()
+    fileStream.destroy()
+  })
+  writableStream.on('error', () => {
+    watcher.close()
+    fileStream.destroy()
+  })
+}
+
+async function getLogIndexes () {
+  const runtimeLogFiles = await getLogFiles()
+  return runtimeLogFiles
+    .map((file) => parseInt(file.slice('logs.'.length)))
+}
+
+async function getLogFileStream (logFileIndex) {
+  const filePath = join(runtimeTmpDir, `logs.${logFileIndex}`)
+  return createReadStream(filePath)
+}
+
+module.exports = {
+  pipeLiveLogs,
+  getLogFileStream,
+  getLogIndexes
+}

package/lib/management-api.js

@@ -2,16 +2,16 @@
 
 const { tmpdir, platform } = require('node:os')
 const { join } = require('node:path')
-const { createReadStream } = require('node:fs')
-const { readFile, readdir, mkdir, unlink } = require('node:fs/promises')
+const { readFile, mkdir, unlink } = require('node:fs/promises')
 const fastify = require('fastify')
 const errors = require('./errors')
+const { pipeLiveLogs, getLogFileStream, getLogIndexes } = require('./logs')
 const platformaticVersion = require('../package.json').version
 
 const PLATFORMATIC_TMP_DIR = join(tmpdir(), 'platformatic', 'runtimes')
 const runtimeTmpDir = join(PLATFORMATIC_TMP_DIR, process.pid.toString())
 
-async function createManagementApi (configManager, runtimeApiClient, loggingPort) {
+async function createManagementApi (configManager, runtimeApiClient) {
   const app = fastify()
   app.log.warn(
     'Runtime Management API is in the experimental stage. ' +
@@ -115,64 +115,65 @@ async function createManagementApi (configManager, runtimeApiClient, loggingPort
         .send(res.body)
     })
 
-    app.get('/logs/live', { websocket: true }, async (connection, req) => {
-      const handler = (message) => {
-        for (const log of message.logs) {
-          connection.socket.send(log)
-        }
+    app.get('/metrics/live', { websocket: true }, async (connection) => {
+      const cachedMetrics = runtimeApiClient.getCachedMetrics()
+      const serializedMetrics = cachedMetrics
+        .map((metric) => JSON.stringify(metric))
+        .join('\n')
+      connection.socket.send(serializedMetrics)
+
+      const eventHandler = (metrics) => {
+        const serializedMetrics = JSON.stringify(metrics)
+        connection.socket.send(serializedMetrics)
       }
 
-      loggingPort.on('message', handler)
-      connection.socket.on('close', () => {
-        loggingPort.off('message', handler)
-      })
-      connection.socket.on('error', () => {
-        loggingPort.off('message', handler)
+      runtimeApiClient.on('metrics', eventHandler)
+
+      connection.on('error', () => {
+        runtimeApiClient.off('metrics', eventHandler)
       })
-      connection.socket.on('end', () => {
-        loggingPort.off('message', handler)
+
+      connection.on('close', () => {
+        runtimeApiClient.off('metrics', eventHandler)
       })
     })
 
-    app.get('/logs/history', { websocket: true }, async (connection, req) => {
-      const runtimeTmpFiles = await readdir(runtimeTmpDir)
-      const runtimeLogFiles = runtimeTmpFiles
-        .filter((file) => file.startsWith('logs'))
-        .map((file) => join(runtimeTmpDir, file))
-        .sort()
+    app.get('/logs/live', { websocket: true }, async (connection, req) => {
+      const startLogIndex = req.query.start ? parseInt(req.query.start) : null
 
-      if (runtimeLogFiles.length === 0) {
-        connection.end()
-        return
+      if (startLogIndex) {
+        const logIndexes = await getLogIndexes()
+        if (!logIndexes.includes(startLogIndex)) {
+          throw new errors.LogFileNotFound(startLogIndex)
+        }
       }
 
-      const streamLogFile = (fileIndex) => {
-        const file = runtimeLogFiles[fileIndex]
-        const isLastFile = fileIndex === runtimeLogFiles.length - 1
-
-        const stream = createReadStream(file)
-        stream.pipe(connection, { end: isLastFile })
-
-        stream.on('error', (err) => {
-          app.log.error(err, 'Error streaming log file')
-          connection.end()
-        })
-        stream.on('end', () => {
-          if (isLastFile) {
-            connection.end()
-            return
-          }
-          streamLogFile(fileIndex + 1)
-        })
+      pipeLiveLogs(connection, req.log, startLogIndex)
+    })
+
+    app.get('/logs/indexes', async () => {
+      const logIndexes = await getLogIndexes()
+      return { indexes: logIndexes }
+    })
+
+    app.get('/logs/:id', async (req) => {
+      const { id } = req.params
+
+      const logIndex = parseInt(id)
+      const logIndexes = await getLogIndexes()
+      if (!logIndexes.includes(logIndex)) {
+        throw new errors.LogFileNotFound(logIndex)
       }
-      streamLogFile(0)
+
+      const logFileStream = await getLogFileStream(logIndex)
+      return logFileStream
     })
   }, { prefix: '/api/v1' })
 
   return app
 }
 
-async function startManagementApi (configManager, runtimeApiClient, loggingPort) {
+async function startManagementApi (configManager, runtimeApiClient) {
   const runtimePID = process.pid
 
   let socketPath = null
@@ -192,8 +193,7 @@ async function startManagementApi (configManager, runtimeApiClient, loggingPort)
 
     const managementApi = await createManagementApi(
       configManager,
-      runtimeApiClient,
-      loggingPort
+      runtimeApiClient
     )
 
     if (platform() !== 'win32') {

package/lib/schema.js

@@ -106,24 +106,41 @@ const platformaticRuntimeSchema = {
       }
     },
     undici: {
-      agentOptions: {
-        type: 'object',
-        additionalProperties: true
-      },
-      interceptors: {
-        type: 'array',
-        items: {
+      type: 'object',
+      properties: {
+        agentOptions: {
           type: 'object',
-          properties: {
-            module: {
-              type: 'string'
-            },
-            options: {
-              type: 'object',
-              additionalProperties: true
+          additionalProperties: true
+        },
+        interceptors: {
+          anyOf: [{
+            type: 'array',
+            items: {
+              $ref: '#/$defs/undiciInterceptor'
             }
-          },
-          required: ['module', 'options']
+          }, {
+            type: 'object',
+            properties: {
+              Client: {
+                type: 'array',
+                items: {
+                  $ref: '#/$defs/undiciInterceptor'
+                }
+              },
+              Pool: {
+                type: 'array',
+                items: {
+                  $ref: '#/$defs/undiciInterceptor'
+                }
+              },
+              Agent: {
+                type: 'array',
+                items: {
+                  $ref: '#/$defs/undiciInterceptor'
+                }
+              }
+            }
+          }]
         }
       }
     },
@@ -144,7 +161,22 @@ const platformaticRuntimeSchema = {
     { required: ['autoload', 'entrypoint'] },
     { required: ['services', 'entrypoint'] }
   ],
-  additionalProperties: false
+  additionalProperties: false,
+  $defs: {
+    undiciInterceptor: {
+      type: 'object',
+      properties: {
+        module: {
+          type: 'string'
+        },
+        options: {
+          type: 'object',
+          additionalProperties: true
+        }
+      },
+      required: ['module', 'options']
+    }
+  }
 }
 
 module.exports.schema = platformaticRuntimeSchema

package/lib/start.js

@@ -44,21 +44,10 @@ 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: childLoggingPort ? [childLoggingPort] : [],
+    transferList: config.loggingPort ? [config.loggingPort] : [],
     workerData: { config, dirname },
     env
   })
@@ -116,10 +105,10 @@ async function startWithConfig (configManager, env = process.env) {
   if (config.managementApi) {
     managementApi = await startManagementApi(
       configManager,
-      runtimeApiClient,
-      mainLoggingPort
+      runtimeApiClient
     )
     runtimeApiClient.managementApi = managementApi
+    runtimeApiClient.startCollectingMetrics()
   }
 
   return runtimeApiClient

package/lib/upgrade.js

@@ -0,0 +1,25 @@
+'use strict'
+
+const { join } = require('path')
+const pkg = require('../package.json')
+
+module.exports = async function upgrade (config, version) {
+  const { semgrator } = await import('semgrator')
+
+  const iterator = semgrator({
+    version,
+    path: join(__dirname, 'versions'),
+    input: config,
+    logger: this.logger.child({ name: '@platformatic/runtime' })
+  })
+
+  let result
+
+  for await (const updated of iterator) {
+    result = updated.result
+  }
+
+  result.$schema = `https://platformatic.dev/schemas/v${pkg.version}/runtime`
+
+  return result
+}

package/lib/versions/v1.5.0.js

@@ -0,0 +1,11 @@
+'use strict'
+
+module.exports = {
+  version: '1.5.0',
+  up: function (config) {
+    if (config.watch !== undefined) {
+      delete config.watch
+    }
+    return config
+  }
+}

package/lib/worker.js

@@ -4,7 +4,6 @@ const inspector = require('node:inspector')
 const { tmpdir } = require('node:os')
 const { register, createRequire } = require('node:module')
 const { isatty } = require('node:tty')
-const { pathToFileURL } = require('node:url')
 const { join } = require('node:path')
 const {
   MessageChannel,
@@ -17,6 +16,7 @@ const pretty = require('pino-pretty')
 const { setGlobalDispatcher, Agent } = require('undici')
 const RuntimeApi = require('./api')
 const { MessagePortWritable } = require('./message-port-writable')
+const loadInterceptors = require('./interceptors')
 let loaderPort
 
 const PLATFORMATIC_TMP_DIR = join(tmpdir(), 'platformatic', 'runtimes')
@@ -64,7 +64,7 @@ function createLogger (config) {
     const logsPath = join(PLATFORMATIC_TMP_DIR, process.pid.toString(), 'logs')
     const pinoRoll = pino.transport({
       target: 'pino-roll',
-      options: { file: logsPath, size: '5m', mkdir: true }
+      options: { file: logsPath, mode: 0o600, size: '5m', mkdir: true }
     })
     multiStream.add({ level: 'trace', stream: pinoRoll })
   }
@@ -105,18 +105,6 @@ process.on('unhandledRejection', (err) => {
   }
 })
 
-async function loadInterceptor (_require, module, options) {
-  const url = pathToFileURL(_require.resolve(module))
-  const interceptor = (await import(url)).default
-  return interceptor(options)
-}
-
-function loadInterceptors (_require, interceptors) {
-  return Promise.all(interceptors.map(async ({ module, options }) => {
-    return loadInterceptor(_require, module, options)
-  }))
-}
-
 async function main () {
   const { inspectorOptions } = workerData.config
 
@@ -130,7 +118,7 @@ async function main () {
   }
 
   const interceptors = {}
-
+  const composedInterceptors = []
   if (config.undici?.interceptors) {
     const _require = createRequire(join(workerData.dirname, 'package.json'))
     for (const key of ['Agent', 'Pool', 'Client']) {
@@ -138,6 +126,10 @@ async function main () {
         interceptors[key] = await loadInterceptors(_require, config.undici.interceptors[key])
       }
     }
+
+    if (Array.isArray(config.undici.interceptors)) {
+      composedInterceptors.push(...await loadInterceptors(_require, config.undici.interceptors))
+    }
   }
 
   const globalDispatcher = new Agent({
@@ -146,7 +138,7 @@ async function main () {
   })
   setGlobalDispatcher(globalDispatcher)
 
-  const runtime = new RuntimeApi(workerData.config, logger, loaderPort)
+  const runtime = new RuntimeApi(workerData.config, logger, loaderPort, composedInterceptors)
   runtime.startListening(parentPort)
 
   parentPort.postMessage('plt:init')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "1.27.0",
+  "version": "1.28.0",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -18,51 +18,56 @@
   "homepage": "https://github.com/platformatic/platformatic#readme",
   "devDependencies": {
     "@fastify/express": "^2.3.0",
+    "@fastify/formbody": "^7.4.0",
     "@matteo.collina/tspl": "^0.1.1",
     "borp": "^0.10.0",
     "c8": "^9.1.0",
     "execa": "^8.0.1",
-    "express": "^4.18.2",
+    "express": "^4.18.3",
     "fast-jwt": "^3.3.3",
     "pino-abstract-transport": "^1.1.0",
     "snazzy": "^9.0.0",
     "split2": "^4.2.0",
     "standard": "^17.1.0",
-    "tsd": "^0.30.4",
-    "typescript": "^5.3.3",
-    "undici-oauth-interceptor": "^0.4.2",
+    "tsd": "^0.30.7",
+    "typescript": "^5.4.2",
+    "undici-oidc-interceptor": "^0.5.0",
+    "why-is-node-running": "^2.2.2",
     "ws": "^8.16.0",
-    "@platformatic/sql-graphql": "1.27.0",
-    "@platformatic/sql-mapper": "1.27.0"
+    "@platformatic/sql-graphql": "1.28.0",
+    "@platformatic/sql-mapper": "1.28.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",
+    "change-case-all": "^2.1.0",
+    "close-with-grace": "^1.3.0",
     "commist": "^3.2.0",
     "debounce": "^2.0.0",
     "desm": "^1.3.1",
     "es-main": "^1.3.0",
     "fastest-levenshtein": "^1.0.16",
-    "fastify": "^4.26.0",
-    "fastify-undici-dispatcher": "^0.5.0",
+    "fastify": "^4.26.2",
+    "fastify-undici-dispatcher": "^0.6.0",
     "graphql": "^16.8.1",
     "help-me": "^5.0.0",
     "minimist": "^1.2.8",
-    "pino": "^8.17.2",
+    "pino": "^8.19.0",
     "pino-pretty": "^10.3.1",
+    "semgrator": "^0.3.0",
     "pino-roll": "1.0.0-rc.1",
-    "undici": "^6.6.0",
+    "tail-file-stream": "^0.1.0",
+    "undici": "^6.9.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/composer": "1.27.0",
-    "@platformatic/config": "1.27.0",
-    "@platformatic/generators": "1.27.0",
-    "@platformatic/db": "1.27.0",
-    "@platformatic/service": "1.27.0",
-    "@platformatic/utils": "1.27.0",
-    "@platformatic/telemetry": "1.27.0"
+    "@platformatic/db": "1.28.0",
+    "@platformatic/config": "1.28.0",
+    "@platformatic/generators": "1.28.0",
+    "@platformatic/service": "1.28.0",
+    "@platformatic/composer": "1.28.0",
+    "@platformatic/utils": "1.28.0",
+    "@platformatic/telemetry": "1.28.0"
   },
   "standard": {
     "ignore": [