@platformatic/runtime 2.37.0 → 2.38.0

package/config.d.ts

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

package/lib/logger.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const { once } = require('node:events')
 const { join } = require('node:path')
 const { isatty } = require('node:tty')
 
@@ -17,7 +18,7 @@ const customPrettifiers = {
   }
 }
 
-function createLogger (config, runtimeLogsDir) {
+async function createLogger (config, runtimeLogsDir) {
   const loggerConfig = { ...config.logger }
 
   // PLT_RUNTIME_LOGGER_STDOUT is used in test to reduce verbosity
@@ -62,6 +63,9 @@ function createLogger (config, runtimeLogsDir) {
     })
 
     multiStream.add({ level: 'trace', stream: pinoRoll })
+
+    // Make sure there is a file before continuing otherwise the management API log endpoint might bail out
+    await once(pinoRoll, 'ready')
   }
 
   return [pino({ level: 'trace' }, multiStream), multiStream]

package/lib/runtime.js

@@ -1,16 +1,18 @@
 'use strict'
 
+const { ITC } = require('@platformatic/itc')
+const { ensureLoggableError, executeWithTimeout, deepmerge } = require('@platformatic/utils')
 const { once, EventEmitter } = require('node:events')
 const { createReadStream, watch, existsSync } = require('node:fs')
 const { readdir, readFile, stat, access } = require('node:fs/promises')
 const { STATUS_CODES } = require('node:http')
+const { hostname } = require('node:os')
 const { join } = require('node:path')
-const { setTimeout: sleep } = require('node:timers/promises')
+const { setTimeout: sleep, setImmediate: sleepUntilNextTick } = require('node:timers/promises')
 const { Worker } = require('node:worker_threads')
-const { ITC } = require('@platformatic/itc')
-const { Agent, interceptors: undiciInterceptors, request } = require('undici')
-const { ensureLoggableError, executeWithTimeout, deepmerge } = require('@platformatic/utils')
+const split2 = require('split2')
 const ts = require('tail-file-stream')
+const { Agent, interceptors: undiciInterceptors, request } = require('undici')
 const { createThreadInterceptor } = require('undici-thread-interceptor')
 
 const { checkDependencies, topologicalSort } = require('./dependencies')
@@ -29,9 +31,8 @@ const {
   kITC,
   kHealthCheckTimer,
   kConfig,
-  kLoggerDestination,
-  kLoggingPort,
-  kWorkerStatus
+  kWorkerStatus,
+  kStderrMarker
 } = require('./worker/symbols')
 
 const fastify = require('fastify')
@@ -110,7 +111,7 @@ class Runtime extends EventEmitter {
     }
 
     // Create the logger
-    const [logger, destination] = createLogger(config, this.#runtimeLogsDir)
+    const [logger, destination] = await createLogger(config, this.#runtimeLogsDir)
     this.logger = logger
     this.#loggerDestination = destination
 
@@ -461,6 +462,7 @@ class Runtime extends EventEmitter {
     runtimePID = runtimePID ?? process.pid
 
     const runtimeLogFiles = await this.#getRuntimeLogFiles(runtimePID)
+
     if (runtimeLogFiles.length === 0) {
       writableStream.end()
       return
@@ -958,9 +960,6 @@ class Runtime extends EventEmitter {
     const { restartOnError } = config
     const workerId = `${serviceId}:${index}`
 
-    const { port1: loggerDestination, port2: loggingPort } = new MessageChannel()
-    loggerDestination.on('message', this.#forwardThreadLog.bind(this))
-
     // Handle inspector
     let inspectorOptions
 
@@ -1019,27 +1018,20 @@ class Runtime extends EventEmitter {
         },
         inspectorOptions,
         dirname: this.#configManager.dirname,
-        runtimeLogsDir: this.#runtimeLogsDir,
-        loggingPort
+        runtimeLogsDir: this.#runtimeLogsDir
       },
       argv: serviceConfig.arguments,
       execArgv,
       env: workerEnv,
-      transferList: [loggingPort],
       resourceLimits: {
         maxOldGenerationSizeMb: health.maxHeapTotal
       },
-      /*
-        Important: always set stdout and stderr to true, so that worker's output is not automatically
-        piped to the parent thread. We actually never output the thread output since we replace it
-        with PinoWritable, and disabling the piping avoids us to redeclare some internal Node.js methods.
-
-        The author of this (Paolo and Matteo) are not proud of the solution. Forgive us.
-      */
       stdout: true,
       stderr: true
     })
 
+    this.#handleWorkerStandardStreams(worker, serviceId, workersCount > 1 ? index : undefined)
+
     // Make sure the listener can handle a lot of API requests at once before raising a warning
     worker.setMaxListeners(1e3)
 
@@ -1081,8 +1073,6 @@ class Runtime extends EventEmitter {
     worker[kId] = workersCount > 1 ? workerId : serviceId
     worker[kServiceId] = serviceId
     worker[kWorkerId] = workersCount > 1 ? index : undefined
-    worker[kLoggerDestination] = loggerDestination
-    worker[kLoggingPort] = loggingPort
 
     if (inspectorOptions) {
       worker[kInspectorOptions] = {
@@ -1226,6 +1216,8 @@ class Runtime extends EventEmitter {
         workerUrl = await sendViaITC(worker, 'start')
       }
 
+      await this.#avoidOutOfOrderThreadLogs()
+
       if (workerUrl) {
         this.#url = workerUrl
       }
@@ -1319,6 +1311,8 @@ class Runtime extends EventEmitter {
       await worker.terminate()
     }
 
+    await this.#avoidOutOfOrderThreadLogs()
+
     worker[kWorkerStatus] = 'stopped'
   }
 
@@ -1326,8 +1320,7 @@ class Runtime extends EventEmitter {
     this.#workers.delete(workerId)
 
     worker[kITC].close()
-    worker[kLoggerDestination].close()
-    worker[kLoggingPort].close()
+
     clearTimeout(worker[kHealthCheckTimer])
   }
 
@@ -1466,46 +1459,75 @@ class Runtime extends EventEmitter {
     return runtimesLogFiles.sort((runtime1, runtime2) => runtime1.lastModified - runtime2.lastModified)
   }
 
-  #forwardThreadLog (message) {
-    if (!this.#loggerDestination) {
-      return
+  #handleWorkerStandardStreams (worker, serviceId, workerId) {
+    const pinoOptions = { level: 'trace', name: serviceId }
+
+    if (typeof workerId !== 'undefined') {
+      pinoOptions.base = { pid: process.pid, hostname: hostname(), worker: workerId }
     }
 
-    for (const log of message.logs) {
-      // In order to being able to forward messages serialized in the
-      // worker threads by directly writing to the destinations using multistream
-      // we unfortunately need to reparse the message to set some internal flags
-      // of the destination which are never set since we bypass pino.
-      let message = JSON.parse(log)
-      let { level, time, msg, raw } = message
+    const logger = this.logger.child(pinoOptions)
 
-      try {
-        const parsed = JSON.parse(raw.trimEnd())
+    const selectors = {
+      stdout: { level: 'info', caller: 'STDOUT' },
+      stderr: { level: 'error', caller: 'STDERR' }
+    }
 
-        if (typeof parsed.level === 'number' && typeof parsed.time === 'number') {
-          level = parsed.level
-          time = parsed.time
-          message = parsed
-        } else {
-          message.raw = undefined
-          message.payload = parsed
-        }
-      } catch {
-        if (typeof message.raw === 'string') {
-          message.msg = message.raw.replace(/\n$/, '')
-        }
+    worker.stdout.pipe(split2()).on('data', raw => {
+      let selector = selectors.stdout
 
-        message.raw = undefined
+      if (raw.includes(kStderrMarker)) {
+        selector = selectors.stderr
+        raw = raw.replaceAll(kStderrMarker, '')
       }
 
-      this.#loggerDestination.lastLevel = level
-      this.#loggerDestination.lastTime = time
-      this.#loggerDestination.lastMsg = msg
+      this.#forwardThreadLog(logger, selector, raw)
+    })
+
+    // Whatever is outputted here, it come from a direct process.stderr.write in the thread.
+    // There's nothing we can do about it in regard of out of order logs due to a Node bug.
+    worker.stderr.pipe(split2()).on('data', raw => {
+      this.#forwardThreadLog(logger, selectors.stderr, raw)
+    })
+  }
+
+  #forwardThreadLog (logger, { level, caller }, raw) {
+    if (!this.#loggerDestination) {
+      return
+    }
+
+    // Attempt to check if the message is already in pino format. If so, we directly write it to the destination
+    let message
+    try {
+      message = JSON.parse(raw)
+    } catch (e) {
+      // No-op, we assume the message is raw
+    }
+
+    // Not a pino message, output it
+    if (!message) {
+      // Log the message
+      logger[level]({ caller }, raw.replace(/\n$/, ''))
+    } else if (typeof message?.level === 'number' && typeof message?.time === 'number') {
+      this.#loggerDestination.lastLevel = message.level
+      this.#loggerDestination.lastTime = message.time
+      this.#loggerDestination.lastMsg = message.msg
       this.#loggerDestination.lastObj = message
-      this.#loggerDestination.lastLogger = this.logger
+      this.#loggerDestination.lastLogger = logger
+
+      // Remember to add '\n' back as split2 removed it
+      this.#loggerDestination.write(raw + '\n')
+    } else {
+      logger[level]({ payload: message })
+    }
+  }
 
-      // Never drop the `\n` as the worker thread trimmed the message
-      this.#loggerDestination.write(JSON.stringify(message) + '\n')
+  // Due to Worker Threads implementation via MessagePort, it might happen that if two messages are printed almost
+  // at the same time from a worker and the main thread, the latter always arrives first.
+  // Let's wait few more ticks to ensure the right order.
+  async #avoidOutOfOrderThreadLogs () {
+    for (let i = 0; i < 2; i++) {
+      await sleepUntilNextTick()
     }
   }
 }

package/lib/worker/itc.js

@@ -65,6 +65,9 @@ function setupITC (app, service, dispatcher) {
         if (status === 'starting') {
           await once(app, 'start')
         } else {
+          // This gives a chance to a stackable to perform custom logic
+          globalThis.platformatic.events.emit('start')
+
           await app.start()
         }
 
@@ -84,6 +87,9 @@ function setupITC (app, service, dispatcher) {
         }
 
         if (status !== 'stopped') {
+          // This gives a chance to a stackable to perform custom logic
+          globalThis.platformatic.events.emit('stop')
+
           await app.stop()
         }
 

package/lib/worker/main.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const { EventEmitter } = require('node:events')
-const { createRequire } = require('@platformatic/utils')
 const { hostname } = require('node:os')
 const { join, resolve } = require('node:path')
 const { parentPort, workerData, threadId } = require('node:worker_threads')
@@ -10,6 +9,15 @@ const inspector = require('node:inspector')
 const diagnosticChannel = require('node:diagnostics_channel')
 const { ServerResponse } = require('node:http')
 
+const { createTelemetryThreadInterceptorHooks } = require('@platformatic/telemetry')
+const {
+  createRequire,
+  disablePinoDirectWrite,
+  ensureFlushedWorkerStdio,
+  executeWithTimeout,
+  ensureLoggableError,
+  getPrivateSymbol
+} = require('@platformatic/utils')
 const dotenv = require('dotenv')
 const pino = require('pino')
 const { fetch, setGlobalDispatcher, getGlobalDispatcher, Agent } = require('undici')
@@ -20,31 +28,9 @@ const { RemoteCacheStore, httpCacheInterceptor } = require('./http-cache')
 const { PlatformaticApp } = require('./app')
 const { setupITC } = require('./itc')
 const { loadInterceptors } = require('./interceptors')
-const { createTelemetryThreadInterceptorHooks } = require('@platformatic/telemetry')
+const { kId, kITC, kStderrMarker } = require('./symbols')
 
-const {
-  MessagePortWritable,
-  createPinoWritable,
-  executeWithTimeout,
-  ensureLoggableError
-} = require('@platformatic/utils')
-const { kId, kITC } = require('./symbols')
-
-process.on('uncaughtException', handleUnhandled.bind(null, 'uncaught exception'))
-process.on('unhandledRejection', handleUnhandled.bind(null, 'unhandled rejection'))
-
-globalThis.fetch = fetch
-globalThis[kId] = threadId
-
-let app
-
-const config = workerData.config
-globalThis.platformatic = Object.assign(globalThis.platformatic ?? {}, {
-  logger: createLogger(),
-  events: new EventEmitter()
-})
-
-function handleUnhandled (type, err) {
+function handleUnhandled (app, type, err) {
   const label =
     workerData.worker.count > 1
       ? `worker ${workerData.worker.index} of the service "${workerData.serviceConfig.id}"`
@@ -59,20 +45,37 @@ function handleUnhandled (type, err) {
     })
 }
 
+function patchLogging () {
+  disablePinoDirectWrite()
+  ensureFlushedWorkerStdio()
+
+  const kFormatForStderr = getPrivateSymbol(console, 'kFormatForStderr')
+
+  // To avoid out of order printing on the main thread, instruct console to only print to the stdout.
+  console._stderr = console._stdout
+  console._stderrErrorHandler = console._stdoutErrorHandler
+
+  // To recognize stderr in the main thread, each line is prepended with a special private Unicode character.
+  const originalFormatter = console[kFormatForStderr]
+  console[kFormatForStderr] = function (args) {
+    let string = kStderrMarker + originalFormatter(args).replaceAll('\n', '\n' + kStderrMarker)
+
+    if (string.endsWith(kStderrMarker)) {
+      string = string.slice(0, -1)
+    }
+
+    return string
+  }
+}
+
 function createLogger () {
-  const destination = new MessagePortWritable({ port: workerData.loggingPort })
   const pinoOptions = { level: 'trace', name: workerData.serviceConfig.id }
 
-  if (typeof workerData.worker?.index !== 'undefined') {
+  if (workerData.worker?.count > 1) {
     pinoOptions.base = { pid: process.pid, hostname: hostname(), worker: workerData.worker.index }
   }
 
-  const loggerInstance = pino(pinoOptions, destination)
-
-  Reflect.defineProperty(process, 'stdout', { value: createPinoWritable(loggerInstance, 'info', false, 'STDOUT') })
-  Reflect.defineProperty(process, 'stderr', { value: createPinoWritable(loggerInstance, 'error', false, 'STDERR') })
-
-  return loggerInstance
+  return pino(pinoOptions)
 }
 
 async function performPreloading (...sources) {
@@ -88,6 +91,15 @@ async function performPreloading (...sources) {
 }
 
 async function main () {
+  globalThis.fetch = fetch
+  globalThis[kId] = threadId
+  globalThis.platformatic = Object.assign(globalThis.platformatic ?? {}, {
+    logger: createLogger(),
+    events: new EventEmitter()
+  })
+
+  const config = workerData.config
+
   await performPreloading(config, workerData.serviceConfig)
 
   const service = workerData.serviceConfig
@@ -101,6 +113,7 @@ async function main () {
       path: envfile
     })
   }
+
   if (config.env) {
     Object.assign(process.env, config.env)
   }
@@ -219,7 +232,7 @@ async function main () {
   }
 
   // Create the application
-  app = new PlatformaticApp(
+  const app = new PlatformaticApp(
     service,
     workerData.worker.count > 1 ? workerData.worker.index : undefined,
     service.telemetry,
@@ -230,6 +243,9 @@ async function main () {
     !!config.watch
   )
 
+  process.on('uncaughtException', handleUnhandled.bind(null, app, 'uncaught exception'))
+  process.on('unhandledRejection', handleUnhandled.bind(null, app, 'unhandled rejection'))
+
   await app.init()
 
   if (service.entrypoint && config.basePath) {
@@ -295,5 +311,7 @@ function stripBasePath (basePath) {
   }
 }
 
+patchLogging()
+
 // No need to catch this because there is the unhadledRejection handler on top.
 main()

package/lib/worker/symbols.js

@@ -6,10 +6,11 @@ const kServiceId = Symbol.for('plt.runtime.service.id')
 const kWorkerId = Symbol.for('plt.runtime.worker.id')
 const kITC = Symbol.for('plt.runtime.itc')
 const kHealthCheckTimer = Symbol.for('plt.runtime.worker.healthCheckTimer')
-const kLoggerDestination = Symbol.for('plt.runtime.loggerDestination')
-const kLoggingPort = Symbol.for('plt.runtime.logginPort')
 const kWorkerStatus = Symbol('plt.runtime.worker.status')
 
+// This string marker should be safe to use since it belongs to Unicode private area
+const kStderrMarker = '\ue002'
+
 module.exports = {
   kConfig,
   kId,
@@ -17,7 +18,6 @@ module.exports = {
   kWorkerId,
   kITC,
   kHealthCheckTimer,
-  kLoggerDestination,
-  kLoggingPort,
-  kWorkerStatus
+  kWorkerStatus,
+  kStderrMarker
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "2.37.0",
+  "version": "2.38.0",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -36,12 +36,12 @@
     "typescript": "^5.5.4",
     "undici-oidc-interceptor": "^0.5.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/composer": "2.37.0",
-    "@platformatic/db": "2.37.0",
-    "@platformatic/node": "2.37.0",
-    "@platformatic/service": "2.37.0",
-    "@platformatic/sql-graphql": "2.37.0",
-    "@platformatic/sql-mapper": "2.37.0"
+    "@platformatic/composer": "2.38.0",
+    "@platformatic/db": "2.38.0",
+    "@platformatic/node": "2.38.0",
+    "@platformatic/service": "2.38.0",
+    "@platformatic/sql-mapper": "2.38.0",
+    "@platformatic/sql-graphql": "2.38.0"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
@@ -75,13 +75,13 @@
     "undici": "^7.0.0",
     "undici-thread-interceptor": "^0.11.0",
     "ws": "^8.16.0",
-    "@platformatic/basic": "2.37.0",
-    "@platformatic/config": "2.37.0",
-    "@platformatic/generators": "2.37.0",
-    "@platformatic/telemetry": "2.37.0",
-    "@platformatic/itc": "2.37.0",
-    "@platformatic/utils": "2.37.0",
-    "@platformatic/ts-compiler": "2.37.0"
+    "@platformatic/basic": "2.38.0",
+    "@platformatic/config": "2.38.0",
+    "@platformatic/generators": "2.38.0",
+    "@platformatic/telemetry": "2.38.0",
+    "@platformatic/itc": "2.38.0",
+    "@platformatic/ts-compiler": "2.38.0",
+    "@platformatic/utils": "2.38.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.37.0.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/2.38.0.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "type": "object",
   "properties": {