@sentio/runtime 2.62.0-rc.3 → 2.62.0-rc.5

package/src/processor-runner.ts

@@ -3,7 +3,7 @@
 import fs from 'fs-extra'
 
 import { compressionAlgorithms } from '@grpc/grpc-js'
-import commandLineArgs from 'command-line-args'
+import { Command, InvalidArgumentError } from 'commander'
 import { createServer } from 'nice-grpc'
 import { errorDetailsServerMiddleware } from 'nice-grpc-error-details'
 // import { registry as niceGrpcRegistry } from 'nice-grpc-prometheus'
@@ -33,189 +33,213 @@ try {
 } catch (e) {
   console.error('Failed to parse worker number', e)
 }
-export const optionDefinitions = [
-  { name: 'target', type: String, defaultOption: true },
-  { name: 'port', alias: 'p', type: String, defaultValue: '4000' },
-  { name: 'concurrency', type: Number, defaultValue: 4 },
-  { name: 'batch-count', type: Number, defaultValue: 1 },
-  // { name: 'use-chainserver', type: Boolean, defaultValue: false },
-  {
-    name: 'chains-config',
-    alias: 'c',
-    type: String,
-    defaultValue: 'chains-config.json'
-  },
-  { name: 'chainquery-server', type: String, defaultValue: '' },
-  { name: 'pricefeed-server', type: String, defaultValue: '' },
-  { name: 'log-format', type: String, defaultValue: 'console' },
-  { name: 'debug', type: Boolean, defaultValue: false },
-  { name: 'otlp-debug', type: Boolean, defaultValue: false },
-  { name: 'start-action-server', type: Boolean, defaultValue: false },
-  { name: 'worker', type: Number, defaultValue: workerNum },
-  { name: 'process-timeout', type: Number, defaultValue: 60 },
-  { name: 'worker-timeout', type: Number, defaultValue: parseInt(process.env['WORKER_TIMEOUT_SECONDS'] || '60') },
-  {
-    name: 'enable-partition',
-    type: Boolean,
-    defaultValue: process.env['SENTIO_ENABLE_BINDING_DATA_PARTITION'] === 'true'
+
+function myParseInt(value: string, dummyPrevious: unknown): number {
+  // parseInt takes a string and a radix
+  const parsedValue = parseInt(value, 10)
+  if (isNaN(parsedValue)) {
+    throw new InvalidArgumentError('Not a number.')
   }
-]
+  return parsedValue
+}
 
-const options = commandLineArgs(optionDefinitions, { partial: true })
+// Create Commander.js program
+const program = new Command()
 
-const logLevel = process.env['LOG_LEVEL']?.toLowerCase()
+program
+  .name('processor-runner')
+  .description('Sentio Processor Runtime')
+  .version('2.0.0-development')
+  .option('--target <path>', 'Path to the processor module to load')
+  .option('-p, --port <port>', 'Port to listen on', '4000')
+  .option('--concurrency <number>', 'Number of concurrent workers', myParseInt, 4)
+  .option('--batch-count <number>', 'Batch count for processing', myParseInt, 1)
+  .option('-c, --chains-config <path>', 'Path to chains configuration file', 'chains-config.json')
+  .option('--chainquery-server <url>', 'Chain query server URL', '')
+  .option('--pricefeed-server <url>', 'Price feed server URL', '')
+  .option('--log-format <format>', 'Log format (console|json)', 'console')
+  .option('--debug', 'Enable debug mode', false)
+  .option('--otlp-debug', 'Enable OTLP debug mode', false)
+  .option('--start-action-server', 'Start action server instead of processor server', false)
+  .option('--worker <number>', 'Number of worker threads', myParseInt, workerNum)
+  .option('--process-timeout <seconds>', 'Process timeout in seconds', myParseInt, 60)
+  .option(
+    '--worker-timeout <seconds>',
+    'Worker timeout in seconds',
+    myParseInt,
+    parseInt(process.env['WORKER_TIMEOUT_SECONDS'] || '60')
+  )
+  .option(
+    '--enable-partition',
+    'Enable binding data partition',
+    process.env['SENTIO_ENABLE_BINDING_DATA_PARTITION'] === 'true'
+  )
+  .action(async (options: any) => {
+    try {
+      await startServer(options)
+    } catch (error) {
+      console.error('Failed to start server:', error)
+      process.exit(1)
+    }
+  })
 
-setupLogger(options['log-format'] === 'json', logLevel === 'debug' ? true : options.debug)
-console.debug('Starting with', options.target)
+// Parse arguments
+program.parse()
 
-await setupOTLP(options['otlp-debug'])
+async function startServer(options: any): Promise<void> {
+  const logLevel = process.env['LOG_LEVEL']?.toLowerCase()
 
-Error.stackTraceLimit = 20
+  setupLogger(options['log-format'] === 'json', logLevel === 'debug' ? true : options.debug)
+  console.debug('Starting with', options.target)
 
-configureEndpoints(options)
+  await setupOTLP(options['otlp-debug'])
 
-console.debug('Starting Server', options)
+  Error.stackTraceLimit = 20
 
-let server: any
-let baseService: ProcessorServiceImpl | ServiceManager
-const loader = async () => {
-  const m = await import(options.target)
-  console.debug('Module loaded', m)
-  return m
-}
-if (options['start-action-server']) {
-  server = new ActionServer(loader)
-  server.listen(options.port)
-} else {
-  server = createServer({
-    'grpc.max_send_message_length': 768 * 1024 * 1024,
-    'grpc.max_receive_message_length': 768 * 1024 * 1024,
-    'grpc.default_compression_algorithm': compressionAlgorithms.gzip
-  })
-    // .use(prometheusServerMiddleware())
-    .use(openTelemetryServerMiddleware())
-    .use(errorDetailsServerMiddleware)
+  configureEndpoints(options)
 
-  if (options.worker > 1) {
-    baseService = new ServiceManager(loader, options, server.shutdown)
-  } else {
-    baseService = new ProcessorServiceImpl(loader, options, server.shutdown)
+  console.debug('Starting Server', options)
+
+  let server: any
+  let baseService: ProcessorServiceImpl | ServiceManager
+  const loader = async () => {
+    const m = await import(options.target)
+    console.debug('Module loaded', m)
+    return m
   }
+  if (options['start-action-server']) {
+    server = new ActionServer(loader)
+    server.listen(options.port)
+  } else {
+    server = createServer({
+      'grpc.max_send_message_length': 768 * 1024 * 1024,
+      'grpc.max_receive_message_length': 768 * 1024 * 1024,
+      'grpc.default_compression_algorithm': compressionAlgorithms.gzip
+    })
+      // .use(prometheusServerMiddleware())
+      .use(openTelemetryServerMiddleware())
+      .use(errorDetailsServerMiddleware)
 
-  const service = new FullProcessorServiceImpl(baseService)
+    if (options.worker > 1) {
+      baseService = new ServiceManager(loader, options, server.shutdown)
+    } else {
+      baseService = new ProcessorServiceImpl(loader, options, server.shutdown)
+    }
 
-  server.add(ProcessorDefinition, service)
-  server.add(
-    ProcessorV3Definition,
-    new FullProcessorServiceV3Impl(new ProcessorServiceImplV3(loader, options, server.shutdown))
-  )
-  server.listen('0.0.0.0:' + options.port)
+    const service = new FullProcessorServiceImpl(baseService)
 
-  console.log('Processor Server Started at:', options.port)
-}
+    server.add(ProcessorDefinition, service)
+    server.add(
+      ProcessorV3Definition,
+      new FullProcessorServiceV3Impl(new ProcessorServiceImplV3(loader, options, server.shutdown))
+    )
 
-const metricsPort = 4040
-
-const httpServer = http
-  .createServer(async function (req, res) {
-    if (req.url) {
-      const reqUrl = new URL(req.url, `http://${req.headers.host}`)
-      const queries = reqUrl.searchParams
-      switch (reqUrl.pathname) {
-        // case '/metrics':
-        //   const metrics = await mergedRegistry.metrics()
-        //   res.write(metrics)
-        //   break
-        case '/heap': {
-          try {
-            const file = '/tmp/' + Date.now() + '.heapsnapshot'
-            await dumpHeap(file)
-            // send the file
-            const readStream = fs.createReadStream(file)
-            res.writeHead(200, { 'Content-Type': 'application/json' })
-            readStream.pipe(res)
-            res.end()
-          } catch {
-            res.writeHead(500)
-            res.end()
+    server.listen('0.0.0.0:' + options.port)
+    console.log('Processor Server Started at:', options.port)
+  }
+  const metricsPort = 4040
+
+  const httpServer = http
+    .createServer(async function (req, res) {
+      if (req.url) {
+        const reqUrl = new URL(req.url, `http://${req.headers.host}`)
+        const queries = reqUrl.searchParams
+        switch (reqUrl.pathname) {
+          // case '/metrics':
+          //   const metrics = await mergedRegistry.metrics()
+          //   res.write(metrics)
+          //   break
+          case '/heap': {
+            try {
+              const file = '/tmp/' + Date.now() + '.heapsnapshot'
+              await dumpHeap(file)
+              // send the file
+              const readStream = fs.createReadStream(file)
+              res.writeHead(200, { 'Content-Type': 'application/json' })
+              readStream.pipe(res)
+              res.end()
+            } catch {
+              res.writeHead(500)
+              res.end()
+            }
+            break
           }
-          break
-        }
-        case '/profile': {
-          try {
-            const profileTime = parseInt(queries.get('t') || '1000', 10) || 1000
-            const session = new Session()
-            session.connect()
-
-            await session.post('Profiler.enable')
-            await session.post('Profiler.start')
-
-            await new Promise((resolve) => setTimeout(resolve, profileTime))
-            const { profile } = await session.post('Profiler.stop')
-
-            res.writeHead(200, { 'Content-Type': 'application/json' })
-            res.write(JSON.stringify(profile))
-            session.disconnect()
-          } catch {
-            res.writeHead(500)
+          case '/profile': {
+            try {
+              const profileTime = parseInt(queries.get('t') || '1000', 10) || 1000
+              const session = new Session()
+              session.connect()
+
+              await session.post('Profiler.enable')
+              await session.post('Profiler.start')
+
+              await new Promise((resolve) => setTimeout(resolve, profileTime))
+              const { profile } = await session.post('Profiler.stop')
+
+              res.writeHead(200, { 'Content-Type': 'application/json' })
+              res.write(JSON.stringify(profile))
+              session.disconnect()
+            } catch {
+              res.writeHead(500)
+            }
+            break
           }
-          break
+          default:
+            res.writeHead(404)
         }
-        default:
-          res.writeHead(404)
+      } else {
+        res.writeHead(404)
       }
-    } else {
-      res.writeHead(404)
-    }
-    res.end()
-  })
-  .listen(metricsPort)
+      res.end()
+    })
+    .listen(metricsPort)
 
-console.log('Metric Server Started at:', metricsPort)
+  console.log('Metric Server Started at:', metricsPort)
 
-process
-  .on('SIGINT', function () {
-    shutdownServers(0)
-  })
-  .on('uncaughtException', (err) => {
-    console.error('Uncaught Exception, please checking if await is properly used', err)
-    if (baseService) {
-      baseService.unhandled = err
-    }
-    // shutdownServers(1)
-  })
-  .on('unhandledRejection', (reason, p) => {
-    // @ts-ignore ignore invalid ens error
-    if (reason?.message.startsWith('invalid ENS name (disallowed character: "*"')) {
-      return
-    }
-    console.error('Unhandled Rejection, please checking if await is properly', reason)
-    if (baseService) {
-      baseService.unhandled = reason as Error
-    }
-    // shutdownServers(1)
-  })
+  process
+    .on('SIGINT', function () {
+      shutdownServers(server, httpServer, 0)
+    })
+    .on('uncaughtException', (err) => {
+      console.error('Uncaught Exception, please checking if await is properly used', err)
+      if (baseService) {
+        baseService.unhandled = err
+      }
+      // shutdownServers(1)
+    })
+    .on('unhandledRejection', (reason, p) => {
+      // @ts-ignore ignore invalid ens error
+      if (reason?.message.startsWith('invalid ENS name (disallowed character: "*"')) {
+        return
+      }
+      console.error('Unhandled Rejection, please checking if await is properly', reason)
+      if (baseService) {
+        baseService.unhandled = reason as Error
+      }
+      // shutdownServers(1)
+    })
 
-if (process.env['OOM_DUMP_MEMORY_SIZE_GB']) {
-  let dumping = false
-  const memorySize = parseFloat(process.env['OOM_DUMP_MEMORY_SIZE_GB'])
-  console.log('heap dumping is enabled, limit set to ', memorySize, 'gb')
-  const dir = process.env['OOM_DUMP_DIR'] || '/tmp'
-  setInterval(async () => {
-    const mem = process.memoryUsage()
-    console.log('Current Memory Usage', mem)
-    // if memory usage is greater this size, dump heap and exit
-    if (mem.heapTotal > memorySize * 1024 * 1024 * 1024 && !dumping) {
-      const file = path.join(dir, `${Date.now()}.heapsnapshot`)
-      dumping = true
-      await dumpHeap(file)
-      // force exit and keep pod running
-      process.exit(11)
-    }
-  }, 1000 * 60)
+  if (process.env['OOM_DUMP_MEMORY_SIZE_GB']) {
+    let dumping = false
+    const memorySize = parseFloat(process.env['OOM_DUMP_MEMORY_SIZE_GB']!)
+    console.log('heap dumping is enabled, limit set to ', memorySize, 'gb')
+    const dir = process.env['OOM_DUMP_DIR'] || '/tmp'
+    setInterval(async () => {
+      const mem = process.memoryUsage()
+      console.log('Current Memory Usage', mem)
+      // if memory usage is greater this size, dump heap and exit
+      if (mem.heapTotal > memorySize * 1024 * 1024 * 1024 && !dumping) {
+        const file = path.join(dir, `${Date.now()}.heapsnapshot`)
+        dumping = true
+        await dumpHeap(file)
+        // force exit and keep pod running
+        process.exit(11)
+      }
+    }, 1000 * 60)
+  }
 }
 
-async function dumpHeap(file: string) {
+async function dumpHeap(file: string): Promise<void> {
   console.log('Heap dumping to', file)
   const session = new Session()
   fs.mkdirSync(path.dirname(file), { recursive: true })
@@ -234,7 +258,7 @@ async function dumpHeap(file: string) {
   }
 }
 
-function shutdownServers(exitCode: number) {
+function shutdownServers(server: any, httpServer: any, exitCode: number): void {
   server?.forceShutdown()
   console.log('RPC server shut down')
 

package/src/service-manager.ts

@@ -139,7 +139,8 @@ export class ServiceManager extends ProcessorServiceImpl {
       argv: process.argv,
       workerData: this.workerData
     })
-    this.pool.on('message', (msg) => {
+    // @ts-ignore - Piscina message handling for template instance sync
+    this.pool.on('message', (msg: any) => {
       if (msg.event == 'add_template_instance') {
         // sync the template state from worker to the main thread
         TemplateInstanceState.INSTANCE.addValue(msg.value)