@sentio/runtime 2.59.0-rc.4 → 2.59.0-rc.41

package/src/service-manager.ts

@@ -1,30 +1,21 @@
 import { CallContext } from 'nice-grpc'
 import { Piscina } from 'piscina'
 import {
-  DataBinding,
-  DBRequest,
-  DBResponse,
   DeepPartial,
   Empty,
-  HandlerType,
   ProcessConfigRequest,
   ProcessConfigResponse,
   ProcessResult,
   ProcessStreamRequest,
   ProcessStreamResponse,
+  ProcessStreamResponse_Partitions,
   StartRequest
 } from '@sentio/protos'
-
-import { IStoreContext } from './db-context.js'
 import { Subject } from 'rxjs'
 
-import { processMetrics } from './metrics.js'
 import { MessageChannel } from 'node:worker_threads'
 import { ProcessorServiceImpl } from './service.js'
 import { TemplateInstanceState } from './state.js'
-
-const { process_binding_count, process_binding_time, process_binding_error } = processMetrics
-
 ;(BigInt.prototype as any).toJSON = function () {
   return this.toString()
 }
@@ -34,11 +25,11 @@ export class ServiceManager extends ProcessorServiceImpl {
   private workerData: any = {}
 
   constructor(
-    readonly options: any,
     loader: () => Promise<any>,
+    readonly options: any,
     shutdownHandler?: () => void
   ) {
-    super(loader, shutdownHandler)
+    super(loader, options, shutdownHandler)
     this.workerData.options = options
   }
 
@@ -70,76 +61,56 @@ export class ServiceManager extends ProcessorServiceImpl {
     return await super.stop(request, context)
   }
 
-  async process(request: DataBinding, dbContext?: ChannelStoreContext): Promise<ProcessResult> {
-    if (!this.pool) {
-      await this.initPool()
-    }
-
-    return this.pool.run(
-      { request, workerPort: dbContext?.workerPort },
-      { transferList: dbContext?.workerPort ? [dbContext?.workerPort] : [] }
-    )
-  }
-
   private readonly contexts = new Contexts()
 
   protected async handleRequests(
     requests: AsyncIterable<ProcessStreamRequest>,
     subject: Subject<DeepPartial<ProcessStreamResponse>>
   ) {
+    if (!this.pool) {
+      await this.initPool()
+    }
     for await (const request of requests) {
-      try {
-        // console.debug('received request:', request)
-        if (request.binding) {
-          process_binding_count.add(1)
-
-          // Adjust binding will make some request become invalid by setting UNKNOWN HandlerType
-          // for older SDK version, so we just return empty result for them here
-          if (request.binding.handlerType === HandlerType.UNKNOWN) {
-            subject.next({
-              processId: request.processId,
-              result: ProcessResult.create()
-            })
-            continue
-          }
-
-          const binding = request.binding
-
-          const dbContext = this.contexts.new(request.processId, subject)
-
-          const start = Date.now()
-          this.process(binding, dbContext)
-            .then(async (result) => {
-              subject.next({
-                result,
-                processId: request.processId
-              })
-            })
-            .catch((e) => {
-              dbContext.error(request.processId, e)
-              process_binding_error.add(1)
-            })
-            .finally(() => {
-              const cost = Date.now() - start
-              process_binding_time.add(cost)
-              this.contexts.delete(request.processId)
-            })
-        }
-        if (request.dbResult) {
-          const dbContext = this.contexts.get(request.processId)
-          try {
-            dbContext?.result(request.dbResult)
-          } catch (e) {
-            subject.error(new Error('db result error, process should stop'))
-          }
+      this.handleSingleRequest(request, subject)
+    }
+  }
+
+  async handleSingleRequest(request: ProcessStreamRequest, subject: Subject<DeepPartial<ProcessStreamResponse>>) {
+    const processId = request.processId
+    if (request.binding) {
+      const context = this.contexts.new(processId)
+      context.mainPort.on('message', (resp: ProcessStreamResponse) => {
+        subject.next(resp)
+        if (resp.result) {
+          // last response
+          this.contexts.delete(processId)
         }
-      } catch (e) {
-        // should not happen
-        console.error('unexpect error during handle loop', e)
+      })
+      await this.pool.run(
+        { request, workerPort: context.workerPort, processId },
+        { transferList: [context.workerPort] }
+      )
+    } else {
+      const context = this.contexts.get(processId)
+      if (!context) {
+        console.error('No context found for processId:', processId)
+        throw new Error(`No context found for processId: ${processId}`)
       }
+      context.sendRequest(request)
     }
   }
 
+  async process(processId: number, context: ChannelContext): Promise<ProcessResult | ProcessStreamResponse_Partitions> {
+    if (!this.pool) {
+      await this.initPool()
+    }
+
+    return this.pool.run(
+      { workerPort: context?.workerPort, processId },
+      { transferList: context?.workerPort ? [context?.workerPort] : [] }
+    )
+  }
+
   private async initPool() {
     if (this.pool) {
       await this.pool.close()
@@ -161,17 +132,19 @@ export class ServiceManager extends ProcessorServiceImpl {
   }
 }
 
-export type WorkerMessage = DBRequest & { processId: number }
-
 class Contexts {
-  private contexts: Map<number, ChannelStoreContext> = new Map()
+  private contexts: Map<number, ChannelContext> = new Map()
 
   get(processId: number) {
     return this.contexts.get(processId)
   }
 
-  new(processId: number, subject: Subject<DeepPartial<ProcessStreamResponse>>) {
-    const context = new ChannelStoreContext(subject, processId)
+  new(processId: number) {
+    let context = this.get(processId)
+    if (context) {
+      return context
+    }
+    context = new ChannelContext(processId)
     this.contexts.set(processId, context)
     return context
   }
@@ -181,25 +154,19 @@ class Contexts {
     context?.close()
     this.contexts.delete(processId)
   }
+
+  has(processId: number) {
+    return this.contexts.has(processId)
+  }
 }
 
-export class ChannelStoreContext implements IStoreContext {
+export class ChannelContext {
   channel = new MessageChannel()
 
-  constructor(
-    readonly subject: Subject<DeepPartial<ProcessStreamResponse>>,
-    readonly processId: number
-  ) {
-    this.mainPort.on('message', (req: ProcessStreamRequest) => {
-      subject.next({
-        ...req,
-        processId: processId
-      })
-    })
-  }
+  constructor(readonly processId: number) {}
 
-  sendRequest(request: DeepPartial<Omit<DBRequest, 'opId'>>, timeoutSecs?: number): Promise<DBResponse> {
-    throw new Error('should not be used on main thread')
+  sendRequest(request: ProcessStreamRequest) {
+    this.mainPort.postMessage(request)
   }
 
   get workerPort() {
@@ -210,24 +177,7 @@ export class ChannelStoreContext implements IStoreContext {
     return this.channel.port1
   }
 
-  result(dbResult: DBResponse) {
-    this.mainPort.postMessage(dbResult)
-  }
-
   close(): void {
     this.mainPort.close()
   }
-
-  error(processId: number, e: any): void {
-    console.error('process error', processId, e)
-    const errorResult = ProcessResult.create({
-      states: {
-        error: e?.toString()
-      }
-    })
-    this.subject.next({
-      result: errorResult,
-      processId
-    })
-  }
 }

package/src/service-worker.ts

@@ -1,24 +1,21 @@
 import {
-  DataBinding,
-  DBResponse,
   DeepPartial,
   Empty,
   ProcessConfigRequest,
-  ProcessConfigResponse,
+  ProcessStreamRequest,
   ProcessStreamResponse,
   StartRequest
 } from '@sentio/protos'
 import { CallContext, ServerError, Status } from 'nice-grpc'
-import { PluginManager } from './plugin.js'
 import { errorString } from './utils.js'
 import { freezeGlobalConfig } from './global-config.js'
 import { DebugInfo, RichServerError } from 'nice-grpc-error-details'
-import { recordRuntimeInfo } from './service.js'
+import { ProcessorServiceImpl } from './service.js'
 import { BroadcastChannel, MessagePort, threadId } from 'worker_threads'
 import { Piscina } from 'piscina'
 import { configureEndpoints } from './endpoints.js'
 import { setupLogger } from './logger.js'
-import { AbstractStoreContext } from './db-context.js'
+import { Subject } from 'rxjs'
 
 let started = false
 
@@ -38,16 +35,11 @@ process
     unhandled = reason as Error
     // shutdownServers(1)
   })
+  .on('exit', () => {
+    console.info('Worker thread exiting, threadId:', threadId)
+  })
 
-async function getConfig(request: ProcessConfigRequest, context?: CallContext): Promise<ProcessConfigResponse> {
-  if (!started) {
-    throw new ServerError(Status.UNAVAILABLE, 'Service Not started.')
-  }
-
-  const newConfig = ProcessConfigResponse.fromPartial({})
-  await PluginManager.INSTANCE.configure(newConfig)
-  return newConfig
-}
+let service: ProcessorServiceImpl | undefined
 
 const loader = async (options: any) => {
   if (options.target) {
@@ -59,9 +51,11 @@ const loader = async (options: any) => {
 
 const configureChannel = new BroadcastChannel('configure_channel')
 configureChannel.onmessage = (request: ProcessConfigRequest) => {
-  getConfig(request)
+  service?.getConfig(request, emptyCallContext)
 }
 
+const emptyCallContext = <CallContext>{}
+
 async function start(request: StartRequest, options: any): Promise<Empty> {
   if (started) {
     return {}
@@ -69,24 +63,24 @@ async function start(request: StartRequest, options: any): Promise<Empty> {
   freezeGlobalConfig()
 
   try {
-    await loader(options)
+    service = new ProcessorServiceImpl(() => loader(options), options)
   } catch (e) {
     throw new ServerError(Status.INVALID_ARGUMENT, 'Failed to load processor: ' + errorString(e))
   }
 
-  await PluginManager.INSTANCE.start(request)
+  await service.start(request, emptyCallContext)
   started = true
   return {}
 }
 
 export default async function ({
-  request,
   processId,
+  request: firstRequest,
   workerPort
 }: {
-  request: DataBinding
   processId: number
-  workerPort?: MessagePort
+  request: ProcessStreamRequest
+  workerPort: MessagePort
 }) {
   const { startRequest, configRequest, options } = Piscina.workerData
   if (!started) {
@@ -97,18 +91,19 @@ export default async function ({
 
     if (startRequest) {
       await start(startRequest, options)
-      console.debug('worker started, template instance:', startRequest.templateInstances?.length)
+      console.debug('worker', threadId, ' started, template instance:', startRequest.templateInstances?.length)
     }
 
     if (configRequest) {
-      await getConfig(configRequest)
-      console.debug('worker configured')
+      await service?.getConfig(configRequest, emptyCallContext)
+      console.debug('worker', threadId, ' configured')
     }
   }
 
   if (unhandled) {
     const err = unhandled
     unhandled = undefined
+    console.error('Unhandled exception/rejection in previous request:', err)
     throw new RichServerError(
       Status.UNAVAILABLE,
       'Unhandled exception/rejection in previous request: ' + errorString(err),
@@ -121,30 +116,20 @@ export default async function ({
     )
   }
 
-  const result = await PluginManager.INSTANCE.processBinding(
-    request,
-    undefined,
-    workerPort ? new WorkerStoreContext(workerPort, processId) : undefined
-  )
-  recordRuntimeInfo(result, request.handlerType)
-  return result
-}
-
-class WorkerStoreContext extends AbstractStoreContext {
-  constructor(
-    readonly port: MessagePort,
-    processId: number
-  ) {
-    super(processId)
-    this.port.on('message', (resp: DBResponse) => {
-      this.result(resp)
+  await new Promise<void>((resolve) => {
+    const subject = new Subject<DeepPartial<ProcessStreamResponse>>()
+    subject.subscribe((resp: ProcessStreamResponse) => {
+      workerPort.postMessage(resp)
+      // receive the response from the processor , close and resolve the promise
+      if (resp.result) {
+        resolve()
+        workerPort.close()
+      }
     })
-    this.port.on('close', () => {
-      this.close()
+    workerPort.on('message', (msg: ProcessStreamRequest) => {
+      const request = msg as ProcessStreamRequest
+      service?.handleRequest(request, firstRequest.binding, subject)
     })
-  }
-
-  doSend(req: DeepPartial<ProcessStreamResponse>): void {
-    this.port.postMessage(req)
-  }
+    service?.handleRequest(firstRequest, firstRequest.binding, subject)
+  })
 }

package/src/service.ts

@@ -56,14 +56,17 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
   private readonly enablePreprocess: boolean
 
   private preparedData: PreparedData | undefined
+  readonly enablePartition: boolean
 
-  constructor(loader: () => Promise<any>, shutdownHandler?: () => void) {
+  constructor(loader: () => Promise<any>, options?: any, shutdownHandler?: () => void) {
     this.loader = loader
     this.shutdownHandler = shutdownHandler
 
     this.enablePreprocess = process.env['ENABLE_PREPROCESS']
       ? process.env['ENABLE_PREPROCESS'].toLowerCase() == 'true'
       : false
+
+    this.enablePartition = options?.['enable-partition'] == true
   }
 
   async getConfig(request: ProcessConfigRequest, context: CallContext): Promise<ProcessConfigResponse> {
@@ -413,65 +416,105 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     yield* from(subject).pipe(withAbort(context.signal))
   }
 
+  private dbContexts = new Contexts()
+
   protected async handleRequests(
     requests: AsyncIterable<ProcessStreamRequest>,
     subject: Subject<DeepPartial<ProcessStreamResponse>>
   ) {
-    const contexts = new Contexts()
+    let lastBinding: DataBinding | undefined = undefined
     for await (const request of requests) {
       try {
-        // console.debug('received request:', request)
+        // console.log('received request:', request, 'lastBinding:', lastBinding)
         if (request.binding) {
-          process_binding_count.add(1)
-
-          // Adjust binding will make some request become invalid by setting UNKNOWN HandlerType
-          // for older SDK version, so we just return empty result for them here
-          if (request.binding.handlerType === HandlerType.UNKNOWN) {
-            subject.next({
-              processId: request.processId,
-              result: ProcessResult.create()
-            })
-            continue
-          }
-
-          const binding = request.binding
-          const dbContext = contexts.new(request.processId, subject)
-          const start = Date.now()
-          PluginManager.INSTANCE.processBinding(binding, this.preparedData, dbContext)
-            .then(async (result) => {
-              // await all pending db requests
-              await dbContext.awaitPendings()
-              subject.next({
-                result,
-                processId: request.processId
-              })
-              recordRuntimeInfo(result, binding.handlerType)
-            })
-            .catch((e) => {
-              console.debug(e)
-              dbContext.error(request.processId, e)
-              process_binding_error.add(1)
-            })
-            .finally(() => {
-              const cost = Date.now() - start
-              process_binding_time.add(cost)
-              contexts.delete(request.processId)
-            })
-        }
-        if (request.dbResult) {
-          const dbContext = contexts.get(request.processId)
-          try {
-            dbContext?.result(request.dbResult)
-          } catch (e) {
-            subject.error(new Error('db result error, process should stop'))
-          }
+          lastBinding = request.binding
         }
+        this.handleRequest(request, lastBinding, subject)
       } catch (e) {
         // should not happen
         console.error('unexpect error during handle loop', e)
       }
     }
   }
+
+  async handleRequest(
+    request: ProcessStreamRequest,
+    lastBinding: DataBinding | undefined,
+    subject: Subject<DeepPartial<ProcessStreamResponse>>
+  ) {
+    if (request.binding) {
+      process_binding_count.add(1)
+
+      // Adjust binding will make some request become invalid by setting UNKNOWN HandlerType
+      // for older SDK version, so we just return empty result for them here
+      if (request.binding.handlerType === HandlerType.UNKNOWN) {
+        subject.next({
+          processId: request.processId,
+          result: ProcessResult.create()
+        })
+        return
+      }
+
+      if (this.enablePartition) {
+        try {
+          const partitions = await PluginManager.INSTANCE.partition(request.binding)
+          subject.next({
+            processId: request.processId,
+            partitions
+          })
+        } catch (e) {
+          console.error('Partition error:', e)
+          subject.error(new Error('Partition error: ' + errorString(e)))
+          return
+        }
+      } else {
+        this.startProcess(request.processId, request.binding, subject)
+      }
+    }
+
+    if (request.start) {
+      if (!lastBinding) {
+        console.error('start request received without binding')
+        subject.error(new Error('start request received without binding'))
+        return
+      }
+      this.startProcess(request.processId, lastBinding, subject)
+    }
+
+    if (request.dbResult) {
+      const dbContext = this.dbContexts.get(request.processId)
+      try {
+        dbContext?.result(request.dbResult)
+      } catch (e) {
+        subject.error(new Error('db result error, process should stop'))
+      }
+    }
+  }
+
+  private startProcess(processId: number, binding: DataBinding, subject: Subject<DeepPartial<ProcessStreamResponse>>) {
+    const dbContext = this.dbContexts.new(processId, subject)
+    const start = Date.now()
+    PluginManager.INSTANCE.processBinding(binding, this.preparedData, dbContext)
+      .then(async (result) => {
+        // await all pending db requests
+        await dbContext.awaitPendings()
+        subject.next({
+          result,
+          processId: processId
+        })
+        recordRuntimeInfo(result, binding.handlerType)
+      })
+      .catch((e) => {
+        console.error(e)
+        dbContext.error(processId, e)
+        process_binding_error.add(1)
+      })
+      .finally(() => {
+        const cost = Date.now() - start
+        process_binding_time.add(cost)
+        this.dbContexts.delete(processId)
+      })
+  }
 }
 
 export function recordRuntimeInfo(results: ProcessResult, handlerType: HandlerType) {

package/src/utils.ts

@@ -10,12 +10,22 @@ export function mergeProcessResults(results: ProcessResult[]): Required<ProcessR
     ...ProcessResultFull.create(),
     states: StateResult.create()
   }
+  return mergeProcessResultsInPlace(res, results)
+}
 
+export function mergeProcessResultsInPlace(
+  res: ProcessResult,
+  results: ProcessResult[]
+): Required<ProcessResult, 'states'> {
+  res.states = res.states || StateResult.create()
   for (const r of results) {
-    res.counters = res.counters.concat(r.counters)
-    res.gauges = res.gauges.concat(r.gauges)
-    res.events = res.events.concat(r.events)
-    res.exports = res.exports.concat(r.exports)
+    // not using spread operator since it puts all element on the stack
+    // cause maximum call stack size exceeded error if it's a large array
+    mergeArrayInPlace(res.counters, r.counters)
+    mergeArrayInPlace(res.gauges, r.gauges)
+    mergeArrayInPlace(res.events, r.events)
+    mergeArrayInPlace(res.exports, r.exports)
+    mergeArrayInPlace(res.timeseriesResult, r.timeseriesResult)
     res.states = {
       configUpdated: res.states?.configUpdated || r.states?.configUpdated || false
     }
@@ -23,6 +33,12 @@ export function mergeProcessResults(results: ProcessResult[]): Required<ProcessR
   return res
 }
 
+function mergeArrayInPlace<T>(dst: T[], src: T[]) {
+  for (const r of src) {
+    dst.push(r)
+  }
+}
+
 export function errorString(e: Error): string {
   return e.message + '\n' + e.stack
 }