@sentio/runtime 4.3.5-rc.1 → 4.3.5-rc.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentio/runtime",
-  "version": "4.3.5-rc.1",
+  "version": "4.3.5-rc.3",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",

package/src/db-context.ts

@@ -36,8 +36,69 @@ type ProcessStreamResponseV3Init = MessageInitShape<typeof ProcessStreamResponse
 type Request = NonNullable<MessageInitShape<typeof DBRequestSchema>['op']>
 type RequestType = NonNullable<Request['case']>
 
+// Both ends of a stack carry the useful information, so a deep one is trimmed in the
+// middle rather than at the tail: the top frames are where the late call was actually
+// made (runtime frames are already trimmed off by captureStackTrace), and the bottom
+// ones are the entry point that led there — which is the closest thing to naming the
+// handler that the stack can offer, on the occasions it has not been lost.
+const MAX_HEAD_FRAMES = 8
+const MAX_TAIL_FRAMES = 4
+
+// V8 keeps only the innermost `Error.stackTraceLimit` frames — 10 by default — so on a
+// deep stack the entry point is discarded before we ever see it. Raised just for this
+// capture, since keeping both ends is the entire point, and restored immediately after.
+const STACK_CAPTURE_DEPTH = 50
+
 export const timeoutError = new Error('timeout')
 
+// Name the entity and id, not just the op kind: "get BinanceAlphaPriceEntity 56-0x…"
+// usually points straight at the call site, while a bare "get" rarely does.
+function describeRequest(request: Request): string {
+  switch (request.case) {
+    case 'get':
+      return `get ${request.value.entity} ${request.value.id}`
+    case 'list':
+      return `list ${request.value.entity}`
+    case 'upsert':
+    case 'update':
+    case 'delete': {
+      const entities = [...new Set(request.value.entity ?? [])].join(',')
+      return `${request.case} ${entities} (${request.value.id?.length ?? 0} row(s))`
+    }
+    default:
+      // The oneof can be unset, in which case `case` is undefined.
+      return request.case ?? 'op'
+  }
+}
+
+/**
+ * Keep both ends of a stack, dropping the middle when it is too long to inline.
+ *
+ * A diagnostic must not grow with the depth of what it describes, but truncating from one
+ * end throws away half of what makes it useful: the top frames are where the late call was
+ * made, the bottom ones the entry point that led there.
+ *
+ * Node's own internals are dropped first so the budget goes to frames the reader can act
+ * on — otherwise a deep call inside the test runner or the processor host fills the tail
+ * with `node:internal/...` and pushes the user's entry point into the omitted middle.
+ * V8-synthesised markers like `async Promise.all (index 3)` are not `node:` frames and are
+ * kept; they are often the single most informative line.
+ */
+function boundedFrames(frames: string[]): string[] {
+  const ownCode = frames.filter((frame) => !frame.includes('node:'))
+  // If everything was internal there is nothing better to show.
+  const usable = ownCode.length ? ownCode : frames
+  if (usable.length <= MAX_HEAD_FRAMES + MAX_TAIL_FRAMES) {
+    return usable
+  }
+  const omitted = usable.length - MAX_HEAD_FRAMES - MAX_TAIL_FRAMES
+  return [
+    ...usable.slice(0, MAX_HEAD_FRAMES),
+    `    ... ${omitted} frame(s) omitted ...`,
+    ...usable.slice(-MAX_TAIL_FRAMES)
+  ]
+}
+
 export interface IStoreContext {
   sendRequest(request: Request, timeoutSecs?: number): Promise<DBResponse>
 
@@ -64,7 +125,7 @@ export abstract class AbstractStoreContext implements IStoreContext {
   // Set once the process has finished and the context was closed. Guards
   // against a lingering batch timer emitting after the final result (which
   // would both lose the write and desync the reused processor stream).
-  private closed = false
+  protected closed = false
 
   constructor(readonly processId: number) {}
 
@@ -78,6 +139,10 @@ export abstract class AbstractStoreContext implements IStoreContext {
   abstract doSend(resp: ProcessStreamResponseInit | ProcessStreamResponseV3Init): void
 
   sendRequest(request: Request, timeoutSecs?: number): Promise<DBResponse> {
+    if (this.closed) {
+      return Promise.reject(this.reportLateMessage(`store ${describeRequest(request)}`, this.sendRequest))
+    }
+
     if (STORE_BATCH_IDLE > 0 && STORE_BATCH_SIZE > 1 && request.case === 'upsert') {
       // batch upsert if possible
       return this.sendUpsertInBatch(request.value as DBRequest_DBUpsert)
@@ -169,6 +234,21 @@ export abstract class AbstractStoreContext implements IStoreContext {
     this.doSend({ value: { case: 'result', value: errorResult }, processId })
   }
 
+  /**
+   * Mark the process finished. Must be called synchronously *immediately before*
+   * the final result is emitted — not from a later `.finally()`.
+   *
+   * Once the result is on the stream the driver may hand that stream to another
+   * process, so nothing may follow it. The gap between emitting the result and
+   * close() running is several microtasks wide, which is more than enough for a
+   * detached continuation to wake up and slip a request through: without this the
+   * observed outbound order is ["result", "dbRequest"], exactly what the guards
+   * exist to prevent. close() still does the teardown afterwards.
+   */
+  finish() {
+    this.closed = true
+  }
+
   close() {
     this.closed = true
     // Drop any un-flushed batch and cancel its timer so it can never emit
@@ -266,6 +346,53 @@ export abstract class AbstractStoreContext implements IStoreContext {
     }
   }
 
+  /**
+   * Report a message the process tried to emit after it had already finished, and
+   * return the Error describing it.
+   *
+   * Such a message cannot be delivered: the final result was already sent, and the
+   * stream it would go out on has been handed back to the pool and may now belong to
+   * another process — writing to it makes the driver fail *that* process with ERR200
+   * "unexpected ProcessID". Dropping it is the only safe option.
+   *
+   * This always logs rather than relying solely on the rejection, because the late
+   * call is nearly always on a path that already swallows errors — the classic case
+   * being one `Promise.all` branch rejecting while its siblings keep running — so the
+   * rejection alone would be invisible. The Error is built here, at the call site, so
+   * its stack points into the handler code that failed to await.
+   *
+   * `boundary` is the runtime entry point the caller came through; its frame and
+   * everything below it is trimmed from the stack so the very first line the user
+   * reads is their own code rather than two frames of ours.
+   */
+  protected reportLateMessage(what: string, boundary?: (...args: never[]) => unknown): Error {
+    const summary =
+      `[sentio] ${what} was issued after process ${this.processId} had already finished, so it was ` +
+      `dropped. Something in the handler was still running after the handler returned — every store ` +
+      `write, store read and metric must be awaited before the handler completes. A common cause is ` +
+      `one Promise.all() branch rejecting while its siblings keep running: Promise.all rejects ` +
+      `immediately but does NOT cancel the others, so give each branch its own .catch() (or use ` +
+      `Promise.allSettled) to keep them inside the handler.`
+
+    const previousLimit = Error.stackTraceLimit
+    Error.stackTraceLimit = Math.max(previousLimit, STACK_CAPTURE_DEPTH)
+    const err = new Error(summary)
+    Error.captureStackTrace?.(err, boundary ?? this.reportLateMessage)
+    // Read `stack` before restoring: the frames are captured at construction, but forcing
+    // the (lazy) formatting here keeps this independent of when anyone reads it.
+    const captured = err.stack ?? ''
+    Error.stackTraceLimit = previousLimit
+
+    // Inline the frames into `message`. The datasource log view renders only the message,
+    // so a stack left in `err.stack` alone is invisible to the user who has to act on it.
+    const frames = boundedFrames(captured.split('\n').slice(1))
+    if (frames.length) {
+      err.message = `${summary}\nIssued at:\n${frames.join('\n')}`
+    }
+    console.error(err)
+    return err
+  }
+
   async awaitPendings() {
     // Flush any buffered upsert batch and wait for its ack before returning.
     // Callers use this to guarantee every write has been sent AND applied by
@@ -308,6 +435,13 @@ export class DataBindingContext extends AbstractStoreContext implements IDataBin
   }
 
   sendTemplateRequest(templates: Array<TemplateInstance>, unbind: boolean) {
+    if (this.closed) {
+      this.reportLateMessage(
+        `${unbind ? 'unbind' : 'bind'} of ${templates.length} template instance(s)`,
+        this.sendTemplateRequest
+      )
+      return
+    }
     this.subject.next({
       processId: this.processId,
       value: {
@@ -320,6 +454,10 @@ export class DataBindingContext extends AbstractStoreContext implements IDataBin
     })
   }
   sendTimeseriesRequest(timeseries: Array<TimeseriesResult>) {
+    if (this.closed) {
+      this.reportLateMessage(`${timeseries.length} timeseries record(s)`, this.sendTimeseriesRequest)
+      return
+    }
     this.subject.next({
       processId: this.processId,
       value: {

package/src/service-v3.ts

@@ -181,6 +181,11 @@ export class ProcessorServiceImplV3 implements ServiceImpl<typeof ProcessorV3> {
         const otherResults = clone(ProcessResultSchema, result)
         otherResults.timeseriesResult = []
 
+        // Close the context to further messages in the same synchronous step that
+        // emits the result: after this point the stream may be recycled to another
+        // process, and waiting for the .finally() below would leave a microtask
+        // window in which a detached continuation could still append to it.
+        context.finish()
         subject.next({
           processId,
           value: {
@@ -191,6 +196,7 @@ export class ProcessorServiceImplV3 implements ServiceImpl<typeof ProcessorV3> {
       })
       .catch((e) => {
         console.error(e, e.stack)
+        context.finish() // same reasoning as the success path — error() emits a result too
         context.error(processId, e)
         process_binding_error.add(1)
       })

package/dist/plugin-7YBR3bUA.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"plugin-7YBR3bUA.d.ts","names":[],"sources":["../src/db-context.ts","../src/plugin.ts"],"mappings":"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"}