@platformatic/runtime 2.25.0 → 2.26.0

package/config.d.ts

@@ -5,7 +5,7 @@
  * and run json-schema-to-typescript to regenerate this file.
  */
 
-export type HttpsSchemasPlatformaticDevPlatformaticRuntime2250Json = {
+export type HttpsSchemasPlatformaticDevPlatformaticRuntime2260Json = {
   [k: string]: unknown;
 } & {
   $schema?: string;

package/lib/config.js

@@ -3,6 +3,7 @@
 const { readdir } = require('node:fs/promises')
 const { join, resolve: pathResolve, isAbsolute } = require('node:path')
 
+const { createRequire, loadModule } = require('@platformatic/utils')
 const ConfigManager = require('@platformatic/config')
 const { Store } = require('@platformatic/config')
 
@@ -103,6 +104,15 @@ async function _transformConfig (configManager, args) {
         const serviceConfig = await store.loadConfig(service)
         service.isPLTService = !!serviceConfig.app.isPLTService
         service.type = serviceConfig.app.configType
+        const _require = createRequire(service.path)
+        // This is needed to work around Rust bug on dylibs:
+        // https://github.com/rust-lang/rust/issues/91979
+        // https://github.com/rollup/rollup/issues/5761
+        // TODO(mcollina): we should expose this inside every stackable configuration.
+        serviceConfig.app.modulesToLoad?.forEach((m) => {
+          const toLoad = _require.resolve(m)
+          loadModule(_require, toLoad).catch(() => {})
+        })
       } catch (err) {
         // Fallback if for any reason a dependency is not found
         try {
@@ -120,6 +130,25 @@ async function _transformConfig (configManager, args) {
           service.isPLTService = false
         }
       }
+    } else {
+      // We need to identify the service type
+      const basic = await import('@platformatic/basic')
+      service.isPLTService = false
+      try {
+        const imported = await basic.importStackableAndConfig(service.path)
+        service.type = imported.stackable.default.configType
+        const _require = createRequire(service.path)
+        // This is needed to work around Rust bug on dylibs:
+        // https://github.com/rust-lang/rust/issues/91979
+        // https://github.com/rollup/rollup/issues/5761
+        // TODO(mcollina): we should expose this inside every stackable configuration.
+        imported.stackable.default.modulesToLoad?.forEach((m) => {
+          const toLoad = _require.resolve(m)
+          loadModule(_require, toLoad).catch(() => {})
+        })
+      } catch {
+        // Nothing to do here
+      }
     }
 
     service.entrypoint = service.id === config.entrypoint

package/lib/management-api.js

@@ -13,6 +13,8 @@ const { getRuntimeLogsDir } = require('./utils')
 const PLATFORMATIC_TMP_DIR = join(tmpdir(), 'platformatic', 'runtimes')
 
 async function managementApiPlugin (app, opts) {
+  app.register(require('@fastify/accepts'))
+
   const runtime = opts.runtime
 
   app.get('/status', async () => {
@@ -113,6 +115,19 @@ async function managementApiPlugin (app, opts) {
     reply.code(res.statusCode).headers(res.headers).send(res.body)
   })
 
+  app.get('/metrics', { logLevel: 'debug' }, async (req, reply) => {
+    const accepts = req.accepts()
+
+    if (!accepts.type('text/plain') && accepts.type('application/json')) {
+      const { metrics } = await runtime.getMetrics('json')
+      return metrics
+    }
+
+    reply.type('text/plain')
+    const { metrics } = await runtime.getMetrics('text')
+    return metrics
+  })
+
   app.get('/metrics/live', { websocket: true }, async socket => {
     const cachedMetrics = runtime.getCachedMetrics()
     if (cachedMetrics.length > 0) {

package/lib/runtime.js

@@ -687,7 +687,10 @@ class Runtime extends EventEmitter {
         }
       } catch (e) {
         // The service exited while we were sending the ITC, skip it
-        if (e.code === 'PLT_RUNTIME_SERVICE_NOT_STARTED' || e.code === 'PLT_RUNTIME_SERVICE_EXIT') {
+        if (
+          e.code === 'PLT_RUNTIME_SERVICE_NOT_STARTED' ||
+          e.code === 'PLT_RUNTIME_SERVICE_EXIT'
+        ) {
           continue
         }
 
@@ -706,73 +709,104 @@ class Runtime extends EventEmitter {
     try {
       const { metrics } = await this.getMetrics()
 
-      if (metrics === null) {
+      if (metrics === null || metrics.length === 0) {
         return null
       }
 
-      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 p50Value = 0
-      let p90Value = 0
-      let p95Value = 0
-      let p99Value = 0
-
-      const metricName = 'http_request_all_summary_seconds'
-      const httpLatencyMetrics = metrics.filter(metric => metric.name === metricName)
-
-      if (httpLatencyMetrics) {
-        const entrypointMetrics = httpLatencyMetrics.find(
-          metric => metric.values?.[0]?.labels?.serviceId === this.#entrypointId
-        )
-        if (entrypointMetrics) {
-          p50Value = entrypointMetrics.values.find(value => value.labels.quantile === 0.5)?.value || 0
-          p90Value = entrypointMetrics.values.find(value => value.labels.quantile === 0.9)?.value || 0
-          p95Value = entrypointMetrics.values.find(value => value.labels.quantile === 0.95)?.value || 0
-          p99Value = entrypointMetrics.values.find(value => value.labels.quantile === 0.99)?.value || 0
-
-          p50Value = Math.round(p50Value * 1000)
-          p90Value = Math.round(p90Value * 1000)
-          p95Value = Math.round(p95Value * 1000)
-          p99Value = Math.round(p99Value * 1000)
+      const metricsNames = [
+        'process_cpu_percent_usage',
+        'process_resident_memory_bytes',
+        'nodejs_heap_size_total_bytes',
+        'nodejs_heap_size_used_bytes',
+        'nodejs_heap_space_size_total_bytes',
+        'nodejs_eventloop_utilization',
+        'http_request_all_summary_seconds'
+      ]
+
+      const servicesMetrics = {}
+
+      for (const metric of metrics) {
+        const { name, values } = metric
+
+        if (!metricsNames.includes(name)) continue
+        if (!values || values.length === 0) continue
+
+        const labels = values[0].labels
+        const serviceId = labels?.serviceId
+
+        if (!serviceId) {
+          throw new Error('Missing serviceId label in metrics')
         }
+
+        let serviceMetrics = servicesMetrics[serviceId]
+        if (!serviceMetrics) {
+          serviceMetrics = {
+            cpu: 0,
+            rss: 0,
+            totalHeapSize: 0,
+            usedHeapSize: 0,
+            newSpaceSize: 0,
+            oldSpaceSize: 0,
+            elu: 0,
+            latency: {
+              p50: 0,
+              p90: 0,
+              p95: 0,
+              p99: 0
+            }
+          }
+          servicesMetrics[serviceId] = serviceMetrics
+        }
+
+        parsePromMetric(serviceMetrics, metric)
       }
 
-      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
+      function parsePromMetric (serviceMetrics, promMetric) {
+        const { name } = promMetric
 
-      const formattedMetrics = {
-        version: 1,
-        date: new Date().toISOString(),
-        cpu,
-        elu,
-        rss,
-        totalHeapSize,
-        usedHeapSize,
-        newSpaceSize,
-        oldSpaceSize,
-        entrypoint: {
-          latency: {
-            p50: p50Value,
-            p90: p90Value,
-            p95: p95Value,
-            p99: p99Value
+        if (name === 'process_cpu_percent_usage') {
+          serviceMetrics.cpu = promMetric.values[0].value
+          return
+        }
+        if (name === 'process_resident_memory_bytes') {
+          serviceMetrics.rss = promMetric.values[0].value
+          return
+        }
+        if (name === 'nodejs_heap_size_total_bytes') {
+          serviceMetrics.totalHeapSize = promMetric.values[0].value
+          return
+        }
+        if (name === 'nodejs_heap_size_used_bytes') {
+          serviceMetrics.usedHeapSize = promMetric.values[0].value
+          return
+        }
+        if (name === 'nodejs_heap_space_size_total_bytes') {
+          const newSpaceSize = promMetric.values.find(value => value.labels.space === 'new')
+          const oldSpaceSize = promMetric.values.find(value => value.labels.space === 'old')
+
+          serviceMetrics.newSpaceSize = newSpaceSize.value
+          serviceMetrics.oldSpaceSize = oldSpaceSize.value
+          return
+        }
+        if (name === 'nodejs_eventloop_utilization') {
+          serviceMetrics.elu = promMetric.values[0].value
+          return
+        }
+        if (name === 'http_request_all_summary_seconds') {
+          serviceMetrics.latency = {
+            p50: promMetric.values.find(value => value.labels.quantile === 0.5)?.value || 0,
+            p90: promMetric.values.find(value => value.labels.quantile === 0.9)?.value || 0,
+            p95: promMetric.values.find(value => value.labels.quantile === 0.95)?.value || 0,
+            p99: promMetric.values.find(value => value.labels.quantile === 0.99)?.value || 0
           }
         }
       }
 
-      return formattedMetrics
+      return {
+        version: 1,
+        date: new Date().toISOString(),
+        services: servicesMetrics
+      }
     } catch (err) {
       // If any metric is missing, return nothing
       this.logger.warn({ err }, 'Cannot fetch metrics')

package/lib/worker/http-cache.js

@@ -3,27 +3,53 @@
 const { Readable, Writable } = require('node:stream')
 const { kITC } = require('./symbols')
 
+const noop = () => {}
+
 class RemoteCacheStore {
+  #onRequest
+  #onCacheHit
+  #onCacheMiss
+  #logger
+
+  constructor (opts = {}) {
+    this.#onRequest = opts.onRequest ?? noop
+    this.#onCacheHit = opts.onCacheHit ?? noop
+    this.#onCacheMiss = opts.onCacheMiss ?? noop
+    this.#logger = opts.logger
+  }
+
   async get (request) {
+    try {
+      this.#onRequest(request)
+    } catch (err) {
+      this.#logger.error(err, 'Error in onRequest http cache hook')
+    }
+
     const itc = globalThis[kITC]
     if (!itc) return
 
     const cachedValue = await itc.send('getHttpCacheValue', {
       request: this.#sanitizeRequest(request)
     })
-    if (!cachedValue) return
-
-    const readable = new Readable({
-      read () {}
-    })
-
-    Object.defineProperty(readable, 'value', {
-      get () { return cachedValue.response }
-    })
+    if (!cachedValue) {
+      try {
+        this.#onCacheMiss(request)
+      } catch (err) {
+        this.#logger.error(err, 'Error in onCacheMiss http cache hook')
+      }
+      return
+    }
 
+    const readable = new Readable({ read () {} })
     readable.push(cachedValue.payload)
     readable.push(null)
 
+    try {
+      this.#onCacheHit(request, cachedValue.response)
+    } catch (err) {
+      this.#logger.error(err, 'Error in onCacheHit http cache hook')
+    }
+
     return {
       ...cachedValue.response,
       body: readable

package/lib/worker/main.js

@@ -159,7 +159,18 @@ async function main () {
     setGlobalDispatcher(
       getGlobalDispatcher().compose(
         undici.interceptors.cache({
-          store: new RemoteCacheStore(),
+          store: new RemoteCacheStore({
+            onRequest: (opts) => {
+              globalThis.platformatic?.onHttpCacheRequest?.(opts)
+            },
+            onCacheHit: (opts) => {
+              globalThis.platformatic?.onHttpCacheHit?.(opts)
+            },
+            onCacheMiss: (opts) => {
+              globalThis.platformatic?.onHttpCacheMiss?.(opts)
+            },
+            logger: globalThis.platformatic.logger
+          }),
           methods: config.httpCache.methods ?? ['GET', 'HEAD']
         })
       )

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "2.25.0",
+  "version": "2.26.0",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -35,12 +35,12 @@
     "typescript": "^5.5.4",
     "undici-oidc-interceptor": "^0.5.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/composer": "2.25.0",
-    "@platformatic/db": "2.25.0",
-    "@platformatic/node": "2.25.0",
-    "@platformatic/service": "2.25.0",
-    "@platformatic/sql-graphql": "2.25.0",
-    "@platformatic/sql-mapper": "2.25.0"
+    "@platformatic/composer": "2.26.0",
+    "@platformatic/db": "2.26.0",
+    "@platformatic/node": "2.26.0",
+    "@platformatic/service": "2.26.0",
+    "@platformatic/sql-graphql": "2.26.0",
+    "@platformatic/sql-mapper": "2.26.0"
   },
   "dependencies": {
     "@fastify/error": "^4.0.0",
@@ -72,13 +72,13 @@
     "undici": "^7.0.0",
     "undici-thread-interceptor": "^0.10.0",
     "ws": "^8.16.0",
-    "@platformatic/basic": "2.25.0",
-    "@platformatic/generators": "2.25.0",
-    "@platformatic/config": "2.25.0",
-    "@platformatic/ts-compiler": "2.25.0",
-    "@platformatic/telemetry": "2.25.0",
-    "@platformatic/itc": "2.25.0",
-    "@platformatic/utils": "2.25.0"
+    "@platformatic/basic": "2.26.0",
+    "@platformatic/generators": "2.26.0",
+    "@platformatic/itc": "2.26.0",
+    "@platformatic/telemetry": "2.26.0",
+    "@platformatic/ts-compiler": "2.26.0",
+    "@platformatic/config": "2.26.0",
+    "@platformatic/utils": "2.26.0"
   },
   "scripts": {
     "test": "npm run lint && borp --concurrency=1 --timeout=300000 && tsd",

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/2.25.0.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/2.26.0.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "type": "object",
   "properties": {