@platformatic/runtime 3.5.1 → 3.7.0

package/config.d.ts

@@ -48,6 +48,7 @@ export type PlatformaticRuntimeConfig = {
     [k: string]: unknown;
   }[];
   workers?: number | string;
+  workersRestartDelay?: number | string;
   logger?: {
     level: (
       | ("fatal" | "error" | "warn" | "info" | "debug" | "trace" | "silent")

package/index.js

@@ -36,9 +36,13 @@ function handleSignal (runtime, config) {
     }
   }
 
+  function onTimeout (timeout) {
+    runtime.logger.error(`Could not close the runtime in ${timeout} ms, aborting the process with exit code 1.`)
+  }
+
   process.on('newListener', filterCloseWithGraceSIGUSR2)
 
-  const cwg = closeWithGrace({ delay: config.gracefulShutdown?.runtime ?? 10000 }, async event => {
+  const cwg = closeWithGrace({ delay: config.gracefulShutdown?.runtime ?? 10000, onTimeout }, async event => {
     if (event.err instanceof Error) {
       console.error(event.err)
     }

package/lib/errors.js

@@ -105,7 +105,7 @@ export const CannotMapSpecifierToAbsolutePathError = createError(
 )
 export const NodeInspectorFlagsNotSupportedError = createError(
   `${ERROR_PREFIX}_NODE_INSPECTOR_FLAGS_NOT_SUPPORTED`,
-  "The Node.js inspector flags are not supported. Please use 'platformatic start --inspect' instead."
+  "The Node.js inspector flags are not supported. Please use 'wattpm start --inspect' instead."
 )
 export const FailedToUnlinkManagementApiSocket = createError(
   `${ERROR_PREFIX}_FAILED_TO_UNLINK_MANAGEMENT_API_SOCKET`,

package/lib/generator.js

@@ -103,9 +103,9 @@ export class RuntimeGenerator extends BaseGenerator {
     const template = {
       name: `${this.runtimeName}`,
       scripts: {
-        dev: this.config.devCommand,
-        build: this.config.buildCommand,
-        start: this.config.startCommand ?? 'platformatic start'
+        dev: this.config.devCommand ?? 'wattpm dev',
+        build: this.config.buildCommand ?? 'wattpm build',
+        start: this.config.startCommand ?? 'wattpm start'
       },
       devDependencies: {
         fastify: `^${this.fastifyVersion}`
@@ -594,7 +594,7 @@ export class WrappedGenerator extends BaseGenerator {
     scripts ??= {}
     scripts.dev ??= this.config.devCommand
     scripts.build ??= this.config.buildCommand
-    scripts.start ??= this.config.startCommand ?? 'platformatic start'
+    scripts.start ??= this.config.startCommand ?? 'wattpm start'
 
     this.addFile({
       path: '',

package/lib/management-api.js

@@ -36,9 +36,10 @@ export async function managementApiPlugin (app, opts) {
     await runtime.close()
   })
 
-  app.post('/restart', async () => {
-    app.log.debug('restart applications')
-    await runtime.restart()
+  app.post('/restart', async request => {
+    const applications = request.body?.applications ?? []
+    app.log.debug({ applications }, 'restart applications')
+    await runtime.restart(applications)
   })
 
   app.get('/applications', async () => {

package/lib/runtime.js

@@ -337,14 +337,19 @@ export class Runtime extends EventEmitter {
     this.#updateStatus('stopped')
   }
 
-  async restart () {
-    this.emit('restarting')
+  async restart (applications = []) {
+    this.emitAndNotify('restarting')
 
-    await this.stop()
-    this.#meshInterceptor.restart()
-    await this.start()
+    const restartInvocations = []
+    for (const application of this.getApplicationsIds()) {
+      if (applications.length === 0 || applications.includes(application)) {
+        restartInvocations.push([application])
+      }
+    }
+
+    await executeInParallel(this.restartApplication.bind(this), restartInvocations, this.#concurrency)
 
-    this.emit('restarted')
+    this.emitAndNotify('restarted')
 
     return this.#url
   }
@@ -362,6 +367,10 @@ export class Runtime extends EventEmitter {
       await this.#prometheusServer.close()
     }
 
+    if (this.#sharedHttpCache?.close) {
+      await this.#sharedHttpCache.close()
+    }
+
     if (this.logger) {
       this.#loggerDestination?.end()
 
@@ -369,10 +378,6 @@ export class Runtime extends EventEmitter {
       this.#loggerDestination = null
     }
 
-    if (this.#sharedHttpCache?.close) {
-      await this.#sharedHttpCache.close()
-    }
-
     this.#updateStatus('closed')
   }
 
@@ -432,13 +437,13 @@ export class Runtime extends EventEmitter {
     }
   }
 
-  emit (event, payload) {
+  emitAndNotify (event, ...payload) {
     for (const worker of this.#workers.values()) {
       worker[kITC].notify('runtime:event', { event, payload })
     }
 
     this.logger.trace({ event, payload }, 'Runtime event')
-    return super.emit(event, payload)
+    return this.emit(event, ...payload)
   }
 
   async sendCommandToApplication (id, name, message) {
@@ -473,13 +478,13 @@ export class Runtime extends EventEmitter {
 
     const workersCount = await this.#workers.getCount(applicationConfig.id)
 
-    this.emit('application:starting', id)
+    this.emitAndNotify('application:starting', id)
 
     for (let i = 0; i < workersCount; i++) {
       await this.#startWorker(config, applicationConfig, workersCount, id, i, silent)
     }
 
-    this.emit('application:started', id)
+    this.emitAndNotify('application:started', id)
   }
 
   async stopApplication (id, silent = false, dependents = []) {
@@ -492,7 +497,7 @@ export class Runtime extends EventEmitter {
 
     const workersCount = await this.#workers.getCount(applicationConfig.id)
 
-    this.emit('application:stopping', id)
+    this.emitAndNotify('application:stopping', id)
 
     if (typeof workersCount === 'number') {
       const stopInvocations = []
@@ -503,16 +508,37 @@ export class Runtime extends EventEmitter {
       await executeInParallel(this.#stopWorker.bind(this), stopInvocations, this.#concurrency)
     }
 
-    this.emit('application:stopped', id)
+    this.emitAndNotify('application:stopped', id)
+  }
+
+  async restartApplication (id) {
+    const config = this.#config
+    const applicationConfig = this.#config.applications.find(s => s.id === id)
+    const workersCount = await this.#workers.getCount(id)
+
+    this.emitAndNotify('application:restarting', id)
+
+    for (let i = 0; i < workersCount; i++) {
+      const label = `${id}:${i}`
+      const worker = this.#workers.get(label)
+
+      if (i > 0 && config.workersRestartDelay > 0) {
+        await sleep(config.workersRestartDelay)
+      }
+
+      await this.#replaceWorker(config, applicationConfig, workersCount, id, i, worker, true)
+    }
+
+    this.emitAndNotify('application:restarted', id)
   }
 
   async buildApplication (id) {
     const application = await this.#getApplicationById(id)
 
-    this.emit('application:building', id)
+    this.emitAndNotify('application:building', id)
     try {
       await sendViaITC(application, 'build')
-      this.emit('application:built', id)
+      this.emitAndNotify('application:built', id)
     } catch (e) {
       // The application exports no meta, return an empty object
       if (e.code === 'PLT_ITC_HANDLER_NOT_FOUND') {
@@ -570,7 +596,7 @@ export class Runtime extends EventEmitter {
         return
       }
 
-      this.emit('metrics', metrics)
+      this.emitAndNotify('metrics', metrics)
       this.#metrics.push(metrics)
       if (this.#metrics.length > MAX_METRICS_QUEUE_LENGTH) {
         this.#metrics.shift()
@@ -1176,7 +1202,7 @@ export class Runtime extends EventEmitter {
 
   #updateStatus (status, args) {
     this.#status = status
-    this.emit(status, args)
+    this.emitAndNotify(status, args)
   }
 
   #showUrl () {
@@ -1236,7 +1262,7 @@ export class Runtime extends EventEmitter {
 
     await executeInParallel(this.#setupWorker.bind(this), setupInvocations, this.#concurrency)
 
-    this.emit('application:init', id)
+    this.emitAndNotify('application:init', id)
   }
 
   async #setupWorker (config, applicationConfig, workersCount, applicationId, index, enabled = true) {
@@ -1345,7 +1371,7 @@ export class Runtime extends EventEmitter {
 
       const started = worker[kWorkerStatus] === 'started'
       worker[kWorkerStatus] = 'exited'
-      this.emit('application:worker:exited', eventPayload)
+      this.emitAndNotify('application:worker:exited', eventPayload)
 
       this.#cleanupWorker(worker)
 
@@ -1356,7 +1382,7 @@ export class Runtime extends EventEmitter {
       // Wait for the next tick so that crashed from the thread are logged first
       setImmediate(() => {
         if (started && (!config.watch || code !== 0)) {
-          this.emit('application:worker:error', { ...eventPayload, code })
+          this.emitAndNotify('application:worker:error', { ...eventPayload, code })
           this.#broadcastWorkers()
 
           this.logger.warn(`The ${errorLabel} unexpectedly exited with code ${code}.`)
@@ -1377,7 +1403,7 @@ export class Runtime extends EventEmitter {
               }
             )
           } else {
-            this.emit('application:worker:unvailable', eventPayload)
+            this.emitAndNotify('application:worker:unvailable', eventPayload)
             this.logger.warn(`The ${errorLabel} is no longer available.`)
           }
         }
@@ -1407,8 +1433,12 @@ export class Runtime extends EventEmitter {
     worker[kITC].listen()
 
     // Forward events from the worker
+    // Do not use emitAndNotify here since we don't want to forward unknown events
     worker[kITC].on('event', ({ event, payload }) => {
-      this.emit(`application:worker:event:${event}`, { ...eventPayload, payload })
+      event = `application:worker:event:${event}`
+
+      this.emit(event, ...payload)
+      this.logger.trace({ event, payload }, 'Runtime event')
     })
 
     // Only activate watch for the first instance
@@ -1418,7 +1448,7 @@ export class Runtime extends EventEmitter {
       // so that applications can eventually manually trigger a restart. This mechanism is current
       // used by the gateway.
       worker[kITC].on('changed', async () => {
-        this.emit('application:worker:changed', eventPayload)
+        this.emitAndNotify('application:worker:changed', eventPayload)
 
         try {
           const wasStarted = worker[kWorkerStatus].startsWith('start')
@@ -1429,7 +1459,7 @@ export class Runtime extends EventEmitter {
           }
 
           this.logger.info(`The application "${applicationId}" has been successfully reloaded ...`)
-          this.emit('application:worker:reloaded', eventPayload)
+          this.emitAndNotify('application:worker:reloaded', eventPayload)
 
           if (applicationConfig.entrypoint) {
             this.#showUrl()
@@ -1457,7 +1487,7 @@ export class Runtime extends EventEmitter {
 
     worker[kConfig] = { ...applicationConfig, health, workers: workersCount }
     worker[kWorkerStatus] = 'init'
-    this.emit('application:worker:init', eventPayload)
+    this.emitAndNotify('application:worker:init', eventPayload)
 
     return worker
   }
@@ -1501,7 +1531,7 @@ export class Runtime extends EventEmitter {
         health = { elu: -1, heapUsed: -1, heapTotal: -1 }
       }
 
-      this.emit('application:worker:health', {
+      this.emitAndNotify('application:worker:health', {
         id: worker[kId],
         application: id,
         worker: index,
@@ -1530,7 +1560,7 @@ export class Runtime extends EventEmitter {
 
       if (unhealthyChecks === maxUnhealthyChecks) {
         try {
-          this.emit('application:worker:unhealthy', { application: id, worker: index })
+          this.emitAndNotify('application:worker:unhealthy', { application: id, worker: index })
 
           this.logger.error(
             { elu: health.elu, maxELU, memoryUsage: health.heapUsed, maxMemoryUsage: maxHeapUsed },
@@ -1582,7 +1612,7 @@ export class Runtime extends EventEmitter {
     }
 
     worker[kWorkerStatus] = 'starting'
-    this.emit('application:worker:starting', eventPayload)
+    this.emitAndNotify('application:worker:starting', eventPayload)
 
     try {
       let workerUrl
@@ -1590,7 +1620,7 @@ export class Runtime extends EventEmitter {
         workerUrl = await executeWithTimeout(sendViaITC(worker, 'start'), config.startTimeout)
 
         if (workerUrl === kTimeout) {
-          this.emit('application:worker:startTimeout', eventPayload)
+          this.emitAndNotify('application:worker:startTimeout', eventPayload)
           this.logger.info(`The ${label} failed to start in ${config.startTimeout}ms. Forcefully killing the thread.`)
           worker.terminate()
           throw new ApplicationStartTimeoutError(id, config.startTimeout)
@@ -1606,7 +1636,7 @@ export class Runtime extends EventEmitter {
       }
 
       worker[kWorkerStatus] = 'started'
-      this.emit('application:worker:started', eventPayload)
+      this.emitAndNotify('application:worker:started', eventPayload)
       this.#broadcastWorkers()
 
       if (!silent) {
@@ -1645,7 +1675,7 @@ export class Runtime extends EventEmitter {
         }
       }
 
-      this.emit('application:worker:start:error', { ...eventPayload, error })
+      this.emitAndNotify('application:worker:start:error', { ...eventPayload, error })
 
       if (error.code !== 'PLT_RUNTIME_APPLICATION_START_TIMEOUT') {
         this.logger.error({ err: ensureLoggableError(error) }, `Failed to start ${label}: ${error.message}`)
@@ -1659,7 +1689,7 @@ export class Runtime extends EventEmitter {
 
       if (bootstrapAttempt++ >= MAX_BOOTSTRAP_ATTEMPTS || restartOnError === 0) {
         this.logger.error(`Failed to start ${label} after ${MAX_BOOTSTRAP_ATTEMPTS} attempts.`)
-        this.emit('application:worker:start:failed', { ...eventPayload, error })
+        this.emitAndNotify('application:worker:start:failed', { ...eventPayload, error })
         throw error
       }
 
@@ -1695,7 +1725,7 @@ export class Runtime extends EventEmitter {
 
     worker[kWorkerStatus] = 'stopping'
     worker[kITC].removeAllListeners('changed')
-    this.emit('application:worker:stopping', eventPayload)
+    this.emitAndNotify('application:worker:stopping', eventPayload)
 
     const label = this.#workerExtendedLabel(id, index, workersCount)
 
@@ -1710,7 +1740,7 @@ export class Runtime extends EventEmitter {
     try {
       await executeWithTimeout(sendViaITC(worker, 'stop', { force: !!this.error, dependents }), exitTimeout)
     } catch (error) {
-      this.emit('application:worker:stop:error', eventPayload)
+      this.emitAndNotify('application:worker:stop:error', eventPayload)
       this.logger.info({ error: ensureLoggableError(error) }, `Failed to stop ${label}. Killing a worker thread.`)
     } finally {
       worker[kITC].notify('application:worker:stop:processed')
@@ -1729,14 +1759,14 @@ export class Runtime extends EventEmitter {
 
     // If the worker didn't exit in time, kill it
     if (res === kTimeout) {
-      this.emit('application:worker:exit:timeout', eventPayload)
+      this.emitAndNotify('application:worker:exit:timeout', eventPayload)
       await worker.terminate()
     }
 
     await this.#avoidOutOfOrderThreadLogs()
 
     worker[kWorkerStatus] = 'stopped'
-    this.emit('application:worker:stopped', eventPayload)
+    this.emitAndNotify('application:worker:stopped', eventPayload)
     this.#broadcastWorkers()
   }
 
@@ -1814,11 +1844,16 @@ export class Runtime extends EventEmitter {
     await restartPromise
   }
 
-  async #replaceWorker (config, applicationConfig, workersCount, applicationId, index, worker) {
+  async #replaceWorker (config, applicationConfig, workersCount, applicationId, index, worker, silent) {
     const workerId = `${applicationId}:${index}`
+    const label = this.#workerExtendedLabel(applicationId, index, workersCount)
     let newWorker
 
     try {
+      if (!silent) {
+        this.logger.debug(`Preparing to start a replacement for ${label}  ...`)
+      }
+
       // Create a new worker
       newWorker = await this.#setupWorker(config, applicationConfig, workersCount, applicationId, index, false)
 
@@ -1845,6 +1880,9 @@ export class Runtime extends EventEmitter {
       throw e
     }
 
+    if (!silent) {
+      this.logger.debug(`Preparing to stop the old version of ${label} ...`)
+    }
     await this.#stopWorker(workersCount, applicationId, index, false, worker, [])
   }
 
@@ -1952,7 +1990,7 @@ export class Runtime extends EventEmitter {
     }
 
     context.transferList = [port2]
-    this.emit('application:worker:messagingChannel', { application, worker })
+    this.emitAndNotify('application:worker:messagingChannel', { application, worker })
     return port2
   }
 

package/lib/worker/itc.js

@@ -70,12 +70,14 @@ export async function waitEventFromITC (worker, event) {
 }
 
 export function setupITC (controller, application, dispatcher, sharedContext) {
-  const messaging = new MessagingITC(controller.appConfig.id, workerData.config)
+  const logger = globalThis.platformatic.logger
+  const messaging = new MessagingITC(controller.appConfig.id, workerData.config, logger)
 
   Object.assign(globalThis.platformatic ?? {}, {
     messaging: {
       handle: messaging.handle.bind(messaging),
-      send: messaging.send.bind(messaging)
+      send: messaging.send.bind(messaging),
+      notify: messaging.notify.bind(messaging)
     }
   })
 

package/lib/worker/main.js

@@ -23,6 +23,13 @@ import { setupITC } from './itc.js'
 import { SharedContext } from './shared-context.js'
 import { kId, kITC, kStderrMarker } from './symbols.js'
 
+class ForwardingEventEmitter extends EventEmitter {
+  emitAndNotify (event, ...args) {
+    globalThis.platformatic.itc.notify('event', { event, payload: args })
+    return this.emit(event, ...args)
+  }
+}
+
 function handleUnhandled (app, type, err) {
   const label =
     workerData.worker.count > 1
@@ -103,7 +110,7 @@ async function main () {
   globalThis[kId] = threadId
   globalThis.platformatic = Object.assign(globalThis.platformatic ?? {}, {
     logger: createLogger(),
-    events: new EventEmitter()
+    events: new ForwardingEventEmitter()
   })
 
   const config = workerData.config
@@ -217,6 +224,7 @@ async function main () {
   // Setup interaction with parent port
   const itc = setupITC(controller, application, threadDispatcher, sharedContext)
   globalThis[kITC] = itc
+  globalThis.platformatic.itc = itc
 
   itc.notify('init')
 }

package/lib/worker/messaging.js

@@ -1,5 +1,5 @@
-import { executeWithTimeout, kTimeout } from '@platformatic/foundation'
-import { ITC, generateResponse, sanitize } from '@platformatic/itc'
+import { executeWithTimeout, ensureLoggableError, kTimeout } from '@platformatic/foundation'
+import { ITC, parseRequest, generateRequest, generateResponse, sanitize, errors } from '@platformatic/itc'
 import { MessagingError } from '../errors.js'
 import { RoundRobinMap } from './round-robin-map.js'
 import { kITC, kWorkersBroadcast } from './symbols.js'
@@ -11,10 +11,12 @@ export class MessagingITC extends ITC {
   #listener
   #closeResolvers
   #broadcastChannel
+  #notificationsChannels
   #workers
   #sources
+  #logger
 
-  constructor (id, runtimeConfig) {
+  constructor (id, runtimeConfig, logger) {
     super({
       throwOnMissingHandler: true,
       name: `${id}-messaging`
@@ -28,6 +30,14 @@ export class MessagingITC extends ITC {
     this.#broadcastChannel = new BroadcastChannel(kWorkersBroadcast)
     this.#broadcastChannel.onmessage = this.#updateWorkers.bind(this)
 
+    this.#notificationsChannels = new Map()
+
+    const notificationsChannel = new BroadcastChannel(`plt.messaging.notifications-${id}`)
+    notificationsChannel.onmessage = this.#handleNotification.bind(this)
+    this.#notificationsChannels.set(id, notificationsChannel)
+
+    this.#logger = logger
+
     this.listen()
   }
 
@@ -87,6 +97,18 @@ export class MessagingITC extends ITC {
     return response
   }
 
+  notify (application, name, message) {
+    const request = generateRequest(name, message)
+
+    let channel = this.#notificationsChannels.get(application)
+    if (!channel) {
+      channel = new BroadcastChannel(`plt.messaging.notifications-${application}`)
+      this.#notificationsChannels.set(application, channel)
+    }
+
+    channel.postMessage(sanitize(request))
+  }
+
   async addSource (channel) {
     this.#sources.add(channel)
     this.#setupChannel(channel)
@@ -119,6 +141,10 @@ export class MessagingITC extends ITC {
     this.#closeResolvers.resolve()
     this.#broadcastChannel.close()
 
+    for (const channel of this.#notificationsChannels.values()) {
+      channel.close()
+    }
+
     for (const source of this.#sources) {
       source.close()
     }
@@ -166,6 +192,27 @@ export class MessagingITC extends ITC {
     this.#workers.configure(instances)
   }
 
+  async #handleNotification (messageEvent) {
+    let request
+    try {
+      request = parseRequest(messageEvent.data)
+    } catch (err) {
+      this.#logger.error({ err: ensureLoggableError(err) }, 'Failed to parse the notification message.')
+      return
+    }
+
+    try {
+      const handler = this.getHandler(request.name)
+      if (!handler) {
+        throw new errors.HandlerNotFoundError(request.name)
+      }
+
+      await handler(request.data)
+    } catch (error) {
+      this.#logger.error({ error }, `"Handler for the "${request.name}" message failed.`)
+    }
+  }
+
   #handlePendingResponse (channel) {
     for (const { application, request } of channel[kPendingResponses].values()) {
       this._emitResponse(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "3.5.1",
+  "version": "3.7.0",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -34,14 +34,14 @@
     "typescript": "^5.5.4",
     "undici-oidc-interceptor": "^0.5.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/db": "3.5.1",
-    "@platformatic/gateway": "3.5.1",
-    "@platformatic/composer": "3.5.1",
-    "@platformatic/node": "3.5.1",
-    "@platformatic/service": "3.5.1",
-    "@platformatic/sql-graphql": "3.5.1",
-    "@platformatic/wattpm-pprof-capture": "3.5.1",
-    "@platformatic/sql-mapper": "3.5.1"
+    "@platformatic/composer": "3.7.0",
+    "@platformatic/db": "3.7.0",
+    "@platformatic/gateway": "3.7.0",
+    "@platformatic/node": "3.7.0",
+    "@platformatic/sql-graphql": "3.7.0",
+    "@platformatic/sql-mapper": "3.7.0",
+    "@platformatic/service": "3.7.0",
+    "@platformatic/wattpm-pprof-capture": "3.7.0"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
@@ -52,7 +52,7 @@
     "@platformatic/undici-cache-memory": "^0.8.1",
     "@watchable/unpromise": "^1.0.2",
     "change-case-all": "^2.1.0",
-    "close-with-grace": "^2.2.0",
+    "close-with-grace": "^2.3.0",
     "colorette": "^2.0.20",
     "cron": "^4.1.0",
     "debounce": "^2.0.0",
@@ -71,12 +71,12 @@
     "undici": "^7.0.0",
     "undici-thread-interceptor": "^0.14.0",
     "ws": "^8.16.0",
-    "@platformatic/basic": "3.5.1",
-    "@platformatic/generators": "3.5.1",
-    "@platformatic/foundation": "3.5.1",
-    "@platformatic/itc": "3.5.1",
-    "@platformatic/telemetry": "3.5.1",
-    "@platformatic/metrics": "3.5.1"
+    "@platformatic/foundation": "3.7.0",
+    "@platformatic/basic": "3.7.0",
+    "@platformatic/itc": "3.7.0",
+    "@platformatic/metrics": "3.7.0",
+    "@platformatic/generators": "3.7.0",
+    "@platformatic/telemetry": "3.7.0"
   },
   "engines": {
     "node": ">=22.19.0"

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.5.1.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.7.0.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Runtime Config",
   "type": "object",
@@ -926,6 +926,18 @@
       ],
       "default": 1
     },
+    "workersRestartDelay": {
+      "anyOf": [
+        {
+          "type": "number",
+          "minimum": 0
+        },
+        {
+          "type": "string"
+        }
+      ],
+      "default": 0
+    },
     "logger": {
       "type": "object",
       "properties": {