@platformatic/runtime 2.65.0 → 2.66.0

package/lib/runtime.js

@@ -12,6 +12,7 @@ const { Worker } = require('node:worker_threads')
 const ts = require('tail-file-stream')
 const { Agent, interceptors: undiciInterceptors, request } = require('undici')
 const { createThreadInterceptor } = require('undici-thread-interceptor')
+const SonicBoom = require('sonic-boom')
 
 const { checkDependencies, topologicalSort } = require('./dependencies')
 const errors = require('./errors')
@@ -76,6 +77,7 @@ class Runtime extends EventEmitter {
   #sharedHttpCache
   servicesConfigsPatches
   #scheduler
+  #stdio
 
   constructor (configManager, runtimeLogsDir, env) {
     super()
@@ -96,6 +98,13 @@ class Runtime extends EventEmitter {
     this.#restartingWorkers = new Map()
     this.#sharedHttpCache = null
     this.servicesConfigsPatches = new Map()
+
+    if (!this.#configManager.current.logger.captureStdio) {
+      this.#stdio = {
+        stdout: new SonicBoom({ fd: process.stdout.fd }),
+        stderr: new SonicBoom({ fd: process.stderr.fd })
+      }
+    }
   }
 
   async init () {
@@ -1720,26 +1729,26 @@ class Runtime extends EventEmitter {
 
     worker.stdout.setEncoding('utf8')
     worker.stdout.on('data', raw => {
-      let selector = selectors.stdout
-
       if (raw.includes(kStderrMarker)) {
-        selector = selectors.stderr
-        raw = raw.replaceAll(kStderrMarker, '')
+        this.#forwardThreadLog(logger, selectors.stderr, raw.replaceAll(kStderrMarker, ''), 'stderr')
+      } else {
+        this.#forwardThreadLog(logger, selectors.stdout, raw, 'stdout')
       }
-
-      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.setEncoding('utf8')
     worker.stderr.on('data', raw => {
-      this.#forwardThreadLog(logger, selectors.stderr, raw)
+      this.#forwardThreadLog(logger, selectors.stderr, raw, 'stderr')
     })
   }
 
-  #forwardThreadLog (logger, { level, caller }, data) {
-    if (!this.#loggerDestination) {
+  // label is the key in the logger object, either 'stdout' or 'stderr'
+  #forwardThreadLog (logger, { level, caller }, data, label) {
+    // When captureStdio is false, write directly to the logger destination
+    if (!this.#configManager.current.logger.captureStdio) {
+      this.#stdio[label].write(data)
       return
     }
 
@@ -1747,35 +1756,43 @@ class Runtime extends EventEmitter {
     for (const raw of data.split('\n')) {
       // First of all, try to parse the message as JSON
       let message
+      let json
       // The message is a JSON object if it has at least 2 bytes
       if (raw.length >= 2) {
         try {
           message = JSON.parse(raw)
-        } catch (e) {
+          json = true
+        } catch {
           // No-op, we assume the message is raw
         }
       }
 
-      // Not a Pino JSON, accumulate the message and continue
-      if (typeof message?.level !== 'number' || (typeof message?.time !== 'number' && typeof message?.msg !== 'string')) {
-        plainMessages += (plainMessages.length ? '\n' : '') + raw
+      const pinoLog = typeof message?.level === 'number' && typeof message?.time === 'number' && typeof message?.msg === 'string'
+
+      // Directly write to the Pino destination
+      if (pinoLog) {
+        if (!this.#loggerDestination) {
+          continue
+        }
+
+        this.#loggerDestination.lastLevel = message.level
+        this.#loggerDestination.lastTime = message.time
+        this.#loggerDestination.lastMsg = message.msg
+        this.#loggerDestination.lastObj = message
+        this.#loggerDestination.lastLogger = logger
+        this.#loggerDestination.write(raw + '\n')
         continue
       }
 
-      // Before continuing, write any previous plain messages
-      if (plainMessages.length > 0) {
-        logger[level]({ caller }, plainMessages.replace(/\n$/, ''))
-        plainMessages = ''
+      if (json) {
+        logger[level]({ caller, [label]: message })
+        continue
       }
 
-      // Now we directly write to the Pino destination
-      this.#loggerDestination.lastLevel = message.level
-      this.#loggerDestination.lastTime = message.time
-      this.#loggerDestination.lastMsg = message.msg
-      this.#loggerDestination.lastObj = message
-      this.#loggerDestination.lastLogger = logger
-
-      this.#loggerDestination.write(raw + '\n')
+      // Not a Pino JSON nor a JSON object, accumulate the message
+      if (!pinoLog && !json) {
+        plainMessages += (plainMessages.length ? '\n' : '') + raw
+      }
     }
 
     // Write whatever is left

package/lib/schema.js

@@ -1,547 +1,30 @@
 #! /usr/bin/env node
 'use strict'
 
-const telemetry = require('@platformatic/telemetry').schema
-const {
-  schemaComponents: { server, logger, health, healthWithoutDefaults }
-} = require('@platformatic/utils')
+const { schemaComponents } = require('@platformatic/utils')
 
-const env = {
-  type: 'object',
-  additionalProperties: {
-    type: 'string'
-  }
-}
-
-const workers = {
-  anyOf: [
-    {
-      type: 'number',
-      minimum: 1
-    },
-    { type: 'string' }
-  ]
-}
-
-const preload = {
-  anyOf: [
-    { type: 'string', resolvePath: true },
-    {
-      type: 'array',
-      items: {
-        type: 'string',
-        resolvePath: true
-      }
-    }
-  ]
-}
+const pkg = require('../package.json')
 
-const services = {
-  type: 'array',
-  items: {
-    type: 'object',
-    anyOf: [{ required: ['id', 'path'] }, { required: ['id', 'url'] }],
-    properties: {
-      id: {
-        type: 'string'
-      },
-      path: {
-        type: 'string',
-        // This is required for the resolve command to allow empty paths after environment variable replacement
-        allowEmptyPaths: true,
-        resolvePath: true
-      },
-      config: {
-        type: 'string'
-      },
-      url: {
-        type: 'string'
-      },
-      gitBranch: {
-        type: 'string',
-        default: 'main'
-      },
-      useHttp: {
-        type: 'boolean'
-      },
-      workers,
-      health: { ...healthWithoutDefaults, default: undefined },
-      arguments: {
-        type: 'array',
-        items: {
-          type: 'string'
-        }
-      },
-      env,
-      envfile: {
-        type: 'string'
-      },
-      sourceMaps: {
-        type: 'boolean',
-        default: false
-      },
-      packageManager: {
-        type: 'string',
-        enum: ['npm', 'pnpm', 'yarn']
-      },
-      preload,
-      nodeOptions: {
-        type: 'string'
-      },
-      telemetry: {
-        type: 'object',
-        properties: {
-          instrumentations: {
-            type: 'array',
-            description: 'An array of instrumentations loaded if telemetry is enabled',
-            items: {
-              oneOf: [
-                {
-                  type: 'string'
-                },
-                {
-                  type: 'object',
-                  properties: {
-                    package: {
-                      type: 'string'
-                    },
-                    exportName: {
-                      type: 'string'
-                    },
-                    options: {
-                      type: 'object',
-                      additionalProperties: true
-                    }
-                  },
-                  required: ['package']
-                }
-              ]
-            }
-          }
-        }
-      }
+const runtimeLogger = {
+  ...schemaComponents.runtimeProperties.logger,
+  properties: {
+    ...schemaComponents.runtimeProperties.logger.properties,
+    captureStdio: {
+      type: 'boolean',
+      default: true
     }
   }
 }
 
-const pkg = require('../package.json')
+schemaComponents.runtimeProperties.logger = runtimeLogger
 
 const platformaticRuntimeSchema = {
   $id: `https://schemas.platformatic.dev/@platformatic/runtime/${pkg.version}.json`,
   $schema: 'http://json-schema.org/draft-07/schema#',
   type: 'object',
-  properties: {
-    $schema: {
-      type: 'string'
-    },
-    preload,
-    entrypoint: {
-      type: 'string'
-    },
-    basePath: {
-      type: 'string'
-    },
-    autoload: {
-      type: 'object',
-      additionalProperties: false,
-      required: ['path'],
-      properties: {
-        path: {
-          type: 'string',
-          resolvePath: true
-        },
-        exclude: {
-          type: 'array',
-          default: [],
-          items: {
-            type: 'string'
-          }
-        },
-        mappings: {
-          type: 'object',
-          additionalProperties: {
-            type: 'object',
-            additionalProperties: false,
-            required: ['id'],
-            properties: {
-              id: {
-                type: 'string'
-              },
-              config: {
-                type: 'string'
-              },
-              useHttp: {
-                type: 'boolean'
-              },
-              workers,
-              health: { ...healthWithoutDefaults, default: undefined },
-              preload,
-              arguments: {
-                type: 'array',
-                items: {
-                  type: 'string'
-                }
-              },
-              nodeOptions: {
-                type: 'string'
-              }
-            }
-          }
-        }
-      }
-    },
-    services,
-    workers: { ...workers, default: 1 },
-    web: services,
-    logger,
-    server,
-    startTimeout: {
-      default: 30000,
-      type: 'number',
-      minimum: 0
-    },
-    restartOnError: {
-      default: true,
-      anyOf: [
-        { type: 'boolean' },
-        {
-          type: 'number',
-          minimum: 0
-        }
-      ]
-    },
-    gracefulShutdown: {
-      type: 'object',
-      properties: {
-        runtime: {
-          anyOf: [
-            {
-              type: 'number',
-              minimum: 1
-            },
-            { type: 'string' }
-          ],
-          default: 10000
-        },
-        service: {
-          anyOf: [
-            {
-              type: 'number',
-              minimum: 1
-            },
-            { type: 'string' }
-          ],
-          default: 10000
-        }
-      },
-      default: {},
-      required: ['runtime', 'service'],
-      additionalProperties: false
-    },
-    health,
-    undici: {
-      type: 'object',
-      properties: {
-        agentOptions: {
-          type: 'object',
-          additionalProperties: true
-        },
-        interceptors: {
-          anyOf: [
-            {
-              type: 'array',
-              items: {
-                $ref: '#/$defs/undiciInterceptor'
-              }
-            },
-            {
-              type: 'object',
-              properties: {
-                Client: {
-                  type: 'array',
-                  items: {
-                    $ref: '#/$defs/undiciInterceptor'
-                  }
-                },
-                Pool: {
-                  type: 'array',
-                  items: {
-                    $ref: '#/$defs/undiciInterceptor'
-                  }
-                },
-                Agent: {
-                  type: 'array',
-                  items: {
-                    $ref: '#/$defs/undiciInterceptor'
-                  }
-                }
-              }
-            }
-          ]
-        }
-      }
-    },
-    httpCache: {
-      oneOf: [
-        {
-          type: 'boolean'
-        },
-        {
-          type: 'object',
-          properties: {
-            store: {
-              type: 'string'
-            },
-            methods: {
-              type: 'array',
-              items: {
-                type: 'string'
-              },
-              default: ['GET', 'HEAD'],
-              minItems: 1
-            },
-            cacheTagsHeader: {
-              type: 'string'
-            },
-            maxSize: {
-              type: 'integer'
-            },
-            maxEntrySize: {
-              type: 'integer'
-            },
-            maxCount: {
-              type: 'integer'
-            }
-          }
-        }
-      ]
-    },
-    watch: {
-      anyOf: [
-        {
-          type: 'boolean'
-        },
-        {
-          type: 'string'
-        }
-      ]
-    },
-    managementApi: {
-      anyOf: [
-        { type: 'boolean' },
-        { type: 'string' },
-        {
-          type: 'object',
-          properties: {
-            logs: {
-              type: 'object',
-              properties: {
-                maxSize: {
-                  type: 'number',
-                  minimum: 5,
-                  default: 200
-                }
-              },
-              additionalProperties: false
-            }
-          },
-          additionalProperties: false
-        }
-      ],
-      default: true
-    },
-    metrics: {
-      anyOf: [
-        { type: 'boolean' },
-        {
-          type: 'object',
-          properties: {
-            port: {
-              anyOf: [{ type: 'integer' }, { type: 'string' }]
-            },
-            enabled: {
-              anyOf: [{
-                type: 'boolean'
-              }, {
-                type: 'string'
-              }]
-            },
-            hostname: { type: 'string' },
-            endpoint: { type: 'string' },
-            auth: {
-              type: 'object',
-              properties: {
-                username: { type: 'string' },
-                password: { type: 'string' }
-              },
-              additionalProperties: false,
-              required: ['username', 'password']
-            },
-            labels: {
-              type: 'object',
-              additionalProperties: { type: 'string' }
-            },
-            readiness: {
-              anyOf: [
-                { type: 'boolean' },
-                {
-                  type: 'object',
-                  properties: {
-                    endpoint: { type: 'string' },
-                    success: {
-                      type: 'object',
-                      properties: {
-                        statusCode: { type: 'number' },
-                        body: { type: 'string' }
-                      },
-                      additionalProperties: false
-                    },
-                    fail: {
-                      type: 'object',
-                      properties: {
-                        statusCode: { type: 'number' },
-                        body: { type: 'string' }
-                      },
-                      additionalProperties: false
-                    }
-                  },
-                  additionalProperties: false
-                }
-              ]
-            },
-            liveness: {
-              anyOf: [
-                { type: 'boolean' },
-                {
-                  type: 'object',
-                  properties: {
-                    endpoint: { type: 'string' },
-                    success: {
-                      type: 'object',
-                      properties: {
-                        statusCode: { type: 'number' },
-                        body: { type: 'string' }
-                      },
-                      additionalProperties: false
-                    },
-                    fail: {
-                      type: 'object',
-                      properties: {
-                        statusCode: { type: 'number' },
-                        body: { type: 'string' }
-                      },
-                      additionalProperties: false
-                    }
-                  },
-                  additionalProperties: false
-                }
-              ]
-            },
-            additionalProperties: false
-          }
-        }
-      ]
-    },
-    telemetry,
-    inspectorOptions: {
-      type: 'object',
-      properties: {
-        host: {
-          type: 'string'
-        },
-        port: {
-          type: 'number'
-        },
-        breakFirstLine: {
-          type: 'boolean'
-        },
-        watchDisabled: {
-          type: 'boolean'
-        }
-      }
-    },
-    serviceTimeout: {
-      anyOf: [
-        {
-          type: 'number',
-          minimum: 1
-        },
-        { type: 'string' }
-      ],
-      default: 300000 // 5 minutes
-    },
-    resolvedServicesBasePath: {
-      type: 'string',
-      default: 'external'
-    },
-    env,
-    sourceMaps: {
-      type: 'boolean',
-      default: false
-    },
-    scheduler: {
-      type: 'array',
-      items: {
-        type: 'object',
-        properties: {
-          enabled: {
-            anyOf: [{
-              type: 'boolean'
-            }, {
-              type: 'string'
-            }],
-            default: true
-          },
-          name: {
-            type: 'string'
-          },
-          cron: {
-            type: 'string'
-          },
-          callbackUrl: {
-            type: 'string'
-          },
-          method: {
-            type: 'string',
-            enum: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'],
-            default: 'GET'
-          },
-          headers: {
-            type: 'object',
-            additionalProperties: {
-              type: 'string'
-            }
-          },
-          body: {
-            anyOf: [{ type: 'string' }, { type: 'object', additionalProperties: true }]
-          },
-          maxRetries: {
-            type: 'number',
-            minimum: 0,
-            default: 3
-          }
-        },
-        required: ['name', 'cron', 'callbackUrl']
-      }
-    }
-  },
+  properties: schemaComponents.runtimeProperties,
   anyOf: [{ required: ['autoload'] }, { required: ['services'] }, { required: ['web'] }],
-  additionalProperties: false,
-  $defs: {
-    undiciInterceptor: {
-      type: 'object',
-      properties: {
-        module: {
-          type: 'string'
-        },
-        options: {
-          type: 'object',
-          additionalProperties: true
-        }
-      },
-      required: ['module', 'options']
-    }
-  }
+  additionalProperties: false
 }
 
 module.exports.schema = platformaticRuntimeSchema