@platformatic/runtime 3.62.1 → 3.62.3

package/config.d.ts

@@ -696,6 +696,10 @@ export type PlatformaticRuntimeConfig = {
     [k: string]: string;
   };
   envfile?: string;
+  /**
+   * When set to true, the configuration loading fails if a {PLT_*} placeholder references an environment variable which is not set. When set to "warn", a warning listing the missing variables is logged but the placeholders are still replaced with an empty string. Defaults to false.
+   */
+  strictEnv?: boolean | string;
   sourceMaps?: boolean;
   nodeModulesSourceMaps?: string[];
   scheduler?: {

package/lib/runtime.js

@@ -1421,20 +1421,6 @@ export class Runtime extends EventEmitter {
         if (applicationMetrics && applicationMetrics !== kTimeout) {
           metrics ??= []
 
-          // Build worker labels including custom labels from metrics config
-          const workerLabels = {
-            ...this.#config.metrics?.labels,
-            [this.#metricsLabelName]: worker[kApplicationId]
-          }
-          const workerId = worker[kWorkerId]
-          if (workerId >= 0) {
-            workerLabels.workerId = workerId
-          }
-
-          // Duplicate process metrics with worker labels and add to output
-          if (processMetricsJson) {
-            this.#applyLabelsToMetrics(processMetricsJson, workerLabels, metrics)
-          }
           // Add worker's thread-specific metrics
           for (let i = 0; i < applicationMetrics.length; i++) {
             metrics.push(applicationMetrics[i])
@@ -1454,6 +1440,24 @@ export class Runtime extends EventEmitter {
       }
     }
 
+    // Report process-level metrics (e.g. process_resident_memory_bytes) only once:
+    // they describe the whole runtime process, so replicating them for each
+    // application running in a worker thread would just duplicate the same value.
+    // Applications running as separate OS processes report their own process-level
+    // metrics, with their own labels, as part of their thread metrics above.
+    // See https://github.com/platformatic/platformatic/issues/3332.
+    if (metrics !== null && processMetricsJson) {
+      const processMetrics = []
+      // Drop any configured custom label that shares the name of the application
+      // label (a config can set both `applicationLabel: 'serviceId'` and a static
+      // `serviceId` label): keeping it would make these runtime-wide metrics look
+      // like they belong to an application, both here and in getFormattedMetrics().
+      const processLabels = { ...this.#config.metrics?.labels }
+      delete processLabels[this.#metricsLabelName]
+      this.#applyLabelsToMetrics(processMetricsJson, processLabels, processMetrics)
+      metrics = [...processMetrics, ...metrics]
+    }
+
     if (metrics !== null && applicationRestartMetrics.length > 0) {
       metrics = [...applicationRestartMetrics, ...metrics]
     }
@@ -1581,6 +1585,13 @@ export class Runtime extends EventEmitter {
 
       const applicationsMetrics = {}
 
+      // Process-level metrics are reported only once for the whole runtime, without
+      // an application label, since they are shared by all the applications running
+      // in worker threads (see issue #3332). Applications running as separate OS
+      // processes report their own labeled values, which take precedence below.
+      const runtimeProcessMetrics = {}
+      const applicationProcessMetrics = new Set()
+
       for (const metric of metrics) {
         const { name, values } = metric
 
@@ -1592,9 +1603,22 @@ export class Runtime extends EventEmitter {
         const applicationId = labels?.[this.#metricsLabelName]
 
         if (!applicationId) {
+          if (name === 'process_cpu_percent_usage') {
+            runtimeProcessMetrics.cpu = values[0].value
+            continue
+          }
+          if (name === 'process_resident_memory_bytes') {
+            runtimeProcessMetrics.rss = values[0].value
+            continue
+          }
+
           throw new Error(`Missing ${this.#metricsLabelName} label in metrics`)
         }
 
+        if (name === 'process_cpu_percent_usage' || name === 'process_resident_memory_bytes') {
+          applicationProcessMetrics.add(`${applicationId}:${name}`)
+        }
+
         let applicationMetrics = applicationsMetrics[applicationId]
         if (!applicationMetrics) {
           applicationMetrics = {
@@ -1618,6 +1642,24 @@ export class Runtime extends EventEmitter {
         parsePromMetric(applicationMetrics, metric)
       }
 
+      // Apply the runtime-wide process-level values to every application that did
+      // not report its own (i.e. every application running in a worker thread).
+      for (const [applicationId, applicationMetrics] of Object.entries(applicationsMetrics)) {
+        if (
+          runtimeProcessMetrics.cpu !== undefined &&
+          !applicationProcessMetrics.has(`${applicationId}:process_cpu_percent_usage`)
+        ) {
+          applicationMetrics.cpu = runtimeProcessMetrics.cpu
+        }
+
+        if (
+          runtimeProcessMetrics.rss !== undefined &&
+          !applicationProcessMetrics.has(`${applicationId}:process_resident_memory_bytes`)
+        ) {
+          applicationMetrics.rss = runtimeProcessMetrics.rss
+        }
+      }
+
       function parsePromMetric (applicationMetrics, promMetric) {
         const { name } = promMetric
 
@@ -2961,7 +3003,7 @@ export class Runtime extends EventEmitter {
       await executeWithTimeout(sendViaITC(worker, 'stop', { force: !!this.error, dependents }), exitTimeout)
     } catch (error) {
       this.emitAndNotify('application:worker:stop:error', eventPayload)
-      this.logger.info({ error: ensureLoggableError(error) }, `Failed to stop ${label}. Killing a worker thread.`)
+      this.logger.error({ err: ensureLoggableError(error) }, `Failed to stop ${label}. Killing a worker thread.`)
     } finally {
       worker[kITC].notify('application:worker:stop:processed')
       // Wait for the processed message to be received

package/lib/worker/controller.js

@@ -95,7 +95,8 @@ export class Controller extends EventEmitter {
       worker: workerData?.worker,
       resourceLimits: workerData?.resourceLimits,
       hasManagementApi: !!runtimeConfig.managementApi,
-      fetchApplicationUrl: fetchApplicationUrl.bind(null, applicationConfig)
+      fetchApplicationUrl: fetchApplicationUrl.bind(null, applicationConfig),
+      strictEnv: runtimeConfig.strictEnv
     }
   }
 
@@ -141,7 +142,8 @@ export class Controller extends EventEmitter {
       if (appConfig.config) {
         // Parse the configuration file the first time to obtain the schema
         const unvalidatedConfig = await loadConfiguration(appConfig.config, null, {
-          onMissingEnv: this.#context.fetchApplicationUrl
+          onMissingEnv: this.#context.fetchApplicationUrl,
+          strictEnv: this.#context.strictEnv
         })
         const pkg = await loadConfigurationModule(appConfig.path, unvalidatedConfig)
         this.capability = await pkg.create(appConfig.path, appConfig.config, this.#context)

package/lib/worker/itc.js

@@ -183,7 +183,12 @@ export async function setupITC (controller, application, dispatcher, sharedConte
 
             // Reply to the runtime that the start failed, so it can cleanup
             once(itc, 'application:worker:start:processed').then(() => {
-              closeITC(dispatcher, itc, messaging).catch(() => {})
+              closeITC(dispatcher, itc, messaging).catch(err => {
+                logger.error(
+                  { err: ensureLoggableError(err) },
+                  'Failed to close the worker ITC after a failed start.'
+                )
+              })
             })
 
             throw ensureLoggableError(e)
@@ -199,23 +204,32 @@ export async function setupITC (controller, application, dispatcher, sharedConte
       },
 
       async stop ({ force, dependents }) {
-        const status = controller.getStatus()
+        try {
+          const status = controller.getStatus()
 
-        if (!force && status === 'starting') {
-          await once(controller, 'start')
-        }
+          if (!force && status === 'starting') {
+            await once(controller, 'start')
+          }
 
-        if (force || status.startsWith('start')) {
-          // This gives a chance to a capability to perform custom logic
-          const events = getEvents()
-          events.emit('stop')
+          if (force || status.startsWith('start')) {
+            // This gives a chance to a capability to perform custom logic
+            const events = getEvents()
+            events.emit('stop')
 
-          await controller.stop(force, dependents)
+            await controller.stop(force, dependents)
+          }
+        } finally {
+          // Always schedule cleanup, even when stop throws. Otherwise the worker
+          // keeps open handles and runtime shutdown hangs until the grace timeout.
+          once(itc, 'application:worker:stop:processed').then(() => {
+            closeITC(dispatcher, itc, messaging).catch(err => {
+              logger.error(
+                { err: ensureLoggableError(err) },
+                'Failed to close the worker ITC after stop.'
+              )
+            })
+          })
         }
-
-        once(itc, 'application:worker:stop:processed').then(() => {
-          closeITC(dispatcher, itc, messaging).catch(() => {})
-        })
       },
 
       async getDependencies () {

package/lib/worker/main.js

@@ -364,6 +364,16 @@ async function main () {
 
 function stripBasePath (basePath) {
   const kBasePath = Symbol('kBasePath')
+  const absoluteUrlPattern = /^https?:\/\//i
+
+  function prependBasePath (value) {
+    // Absolute and protocol-relative URLs (RFC 7231 Location) must not be rewritten
+    if (typeof value !== 'string' || absoluteUrlPattern.test(value) || value.startsWith('//') || value.startsWith(basePath)) {
+      return value
+    }
+
+    return basePath + value
+  }
 
   subscribe('http.server.request.start', ({ request, response }) => {
     if (request.url.startsWith(basePath)) {
@@ -389,8 +399,8 @@ function stripBasePath (basePath) {
 
       if (headers) {
         for (const key in headers) {
-          if (key.toLowerCase() === 'location' && !headers[key].startsWith(basePath)) {
-            headers[key] = basePath + headers[key]
+          if (key.toLowerCase() === 'location') {
+            headers[key] = prependBasePath(headers[key])
           }
         }
       }
@@ -401,8 +411,8 @@ function stripBasePath (basePath) {
 
   ServerResponse.prototype.setHeader = function (name, value) {
     if (this[kBasePath]) {
-      if (name.toLowerCase() === 'location' && !value.startsWith(basePath)) {
-        value = basePath + value
+      if (name.toLowerCase() === 'location') {
+        value = prependBasePath(value)
       }
     }
     originSetHeader.call(this, name, value)

package/lib/worker/messaging.js

@@ -114,14 +114,21 @@ export class MessagingITC extends ITC {
         context.meta = { ...options?.meta, ...telemetry?.meta }
       }
 
-      const send = () => executeWithTimeout(super.send(name, message, context), this.#timeout)
-      const response = telemetry ? await telemetry.run(send) : await send()
-
-      if (response === kTimeout) {
-        throw new MessagingError(application, 'Timeout while waiting for a response.')
+      const abortController = new AbortController()
+      const timeout = setTimeout(() => abortController.abort(), this.#timeout).unref()
+      context.signal = abortController.signal
+
+      try {
+        const send = () => super.send(name, message, context)
+        return telemetry ? await telemetry.run(send) : await send()
+      } catch (err) {
+        if (abortController.signal.aborted) {
+          throw new MessagingError(application, 'Timeout while waiting for a response.')
+        }
+        throw err
+      } finally {
+        clearTimeout(timeout)
       }
-
-      return response
     } catch (err) {
       error = err
       throw err
@@ -181,6 +188,12 @@ export class MessagingITC extends ITC {
     channel.postMessage(sanitize(request, transferList), transferList)
   }
 
+  _onRequestSettled (reqId, context) {
+    if (context.trackResponse) {
+      context.channel[kPendingResponses].delete(reqId)
+    }
+  }
+
   _createClosePromise () {
     const { promise, resolve, reject } = Promise.withResolvers()
     this.#closeResolvers = { resolve, reject }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "3.62.1",
+  "version": "3.62.3",
   "description": "Platformatic runtime",
   "main": "index.js",
   "type": "module",
@@ -39,14 +39,14 @@
     "typescript": "^5.9.3",
     "undici-oidc-interceptor": "^0.9.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/composer": "3.62.1",
-    "@platformatic/db": "3.62.1",
-    "@platformatic/gateway": "3.62.1",
-    "@platformatic/node": "3.62.1",
-    "@platformatic/service": "3.62.1",
-    "@platformatic/sql-mapper": "3.62.1",
-    "@platformatic/sql-graphql": "3.62.1",
-    "@platformatic/wattpm-pprof-capture": "3.62.1"
+    "@platformatic/composer": "3.62.3",
+    "@platformatic/db": "3.62.3",
+    "@platformatic/gateway": "3.62.3",
+    "@platformatic/node": "3.62.3",
+    "@platformatic/service": "3.62.3",
+    "@platformatic/sql-mapper": "3.62.3",
+    "@platformatic/wattpm-pprof-capture": "3.62.3",
+    "@platformatic/sql-graphql": "3.62.3"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
@@ -69,7 +69,7 @@
     "help-me": "^5.0.0",
     "minimist": "^1.2.8",
     "pino": "^10.1.0",
-    "pino-opentelemetry-transport": "^3.0.0",
+    "pino-opentelemetry-transport": "^4.0.2",
     "pino-pretty": "^13.0.0",
     "semgrator": "^0.3.0",
     "sonic-boom": "^4.2.0",
@@ -77,13 +77,13 @@
     "undici": "^7.27.2",
     "undici-thread-interceptor": "^1.3.1",
     "ws": "^8.16.0",
-    "@platformatic/basic": "3.62.1",
-    "@platformatic/foundation": "3.62.1",
-    "@platformatic/generators": "3.62.1",
-    "@platformatic/globals": "3.62.1",
-    "@platformatic/itc": "3.62.1",
-    "@platformatic/telemetry": "3.62.1",
-    "@platformatic/metrics": "3.62.1"
+    "@platformatic/basic": "3.62.3",
+    "@platformatic/foundation": "3.62.3",
+    "@platformatic/generators": "3.62.3",
+    "@platformatic/globals": "3.62.3",
+    "@platformatic/metrics": "3.62.3",
+    "@platformatic/telemetry": "3.62.3",
+    "@platformatic/itc": "3.62.3"
   },
   "engines": {
     "node": ">=22.19.0"

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.62.1.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.62.3.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Runtime Config",
   "type": "object",
@@ -3492,6 +3492,17 @@
     "envfile": {
       "type": "string"
     },
+    "strictEnv": {
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "string"
+        }
+      ],
+      "description": "When set to true, the configuration loading fails if a {PLT_*} placeholder references an environment variable which is not set. When set to \"warn\", a warning listing the missing variables is logged but the placeholders are still replaced with an empty string. Defaults to false."
+    },
     "sourceMaps": {
       "type": "boolean",
       "default": false