@yarkivaev/scada 2.4.5 → 2.4.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yarkivaev/scada",
-  "version": "2.4.5",
+  "version": "2.4.7",
   "description": "SCADA domain objects, state persistence, and plant monitoring",
   "repository": {
     "type": "git",

package/src/infrastructure/ingest/pipelines/segmentPipeline.js

@@ -43,8 +43,8 @@ function segmentSinks(postgres, pool) {
 /**
  * Pipeline for streaming STOMP segment data to PostgreSQL segments table.
  * Subscribes to the durable ingest queue so shovel traffic survives consumer gaps.
- * Pending heartbeats are coalesced per machine. Source acceptance is FIFO:
- * queued lane work must not consume another delivery's execution deadline.
+ * Pending heartbeats are coalesced per machine. Machine lanes run in parallel;
+ * only storage execution consumes its watchdog, not bounded lane queue wait.
  *
  * @param {string} stomp - STOMP broker URL
  * @param {string} postgres - PostgreSQL connection URL
@@ -71,7 +71,10 @@ export default function segmentPipeline(stomp, postgres, pool, config) {
         interval: config.interval
     });
     const destination = config.segmentsDestination || segmentsIngestDestination;
-    source = stompSource(stomp, destination, coalesce, stompOptions(config, { serial: true, manualAck: true }));
+    // Each admitted frame can flush one heartbeat and then persist itself; prefetch bounds queue depth.
+    const deliveryTimeoutMs = Math.min(2147483647, (config.acceptTimeoutMs ?? 10000) * (config.prefetch ?? 32) * 2);
+    source = stompSource(stomp, destination, coalesce,
+        stompOptions(config, { serial: false, manualAck: true, deliveryTimeoutMs }));
     const silence = silentOpenWatch(closeSilentOpen(pool), budget, {
         intervalMs: (config.poll || 5) * 1000
     });

package/src/infrastructure/ingest/pipelines/stompOptions.js

@@ -3,7 +3,7 @@ export default function stompOptions(config, overrides = {}) {
     const options = { login: config.login, passcode: config.passcode, host: config.host,
         prefetch: config.prefetch, maxMessageBytes: config.maxMessageBytes,
         maxPendingBytes: config.maxPendingBytes, budget: config.budget,
-        acceptTimeoutMs: config.acceptTimeoutMs, stopTimeoutMs: config.stopTimeoutMs,
+        acceptTimeoutMs: config.acceptTimeoutMs, deliveryTimeoutMs: config.deliveryTimeoutMs, stopTimeoutMs: config.stopTimeoutMs,
         onError: config.onError, onFatal: config.onFatal, onState: config.onState, ...overrides };
     return Object.fromEntries(Object.entries(options).filter(([, value]) => { return value !== undefined; }));
 }

package/src/infrastructure/ingest/telemetry/amqpMetricsIngest.js

@@ -56,7 +56,10 @@ export function telemetryConsumer(codec, channel, onSeen) {
  */
 export default function amqpMetricsIngest(amqpUrl, queue, sink, options = {}) {
     const prefetch = options.prefetch || 32;
-    const collector = ingestBatch(sink, options);
+    // Unacknowledged deliveries occupy the broker window until the batch commits.
+    // A larger batch can never fill and would throttle ingestion to the flush timer.
+    const size = Math.min(options.size ?? 100, prefetch);
+    const collector = ingestBatch(sink, { ...options, size });
     const codec = metricsCodec(collector);
     const session = amqpSource(amqpUrl, queue, {
         accept(delivery) {

package/src/infrastructure/streams/stompBody.js

@@ -3,8 +3,9 @@ import budgetAccept from './budgetAccept.js';
 
 export function stompSettings(options, prefetch) {
     const config = { acceptTimeoutMs: 10000, stopTimeoutMs: 5000, maxMessageBytes: 1048576, ...options };
+    config.deliveryTimeoutMs ??= config.acceptTimeoutMs;
     config.maxPendingBytes ??= prefetch * config.maxMessageBytes;
-    ['acceptTimeoutMs', 'stopTimeoutMs', 'maxMessageBytes', 'maxPendingBytes'].forEach((key) => { positive(config[key], key); });
+    ['acceptTimeoutMs', 'deliveryTimeoutMs', 'stopTimeoutMs', 'maxMessageBytes', 'maxPendingBytes'].forEach((key) => { positive(config[key], key); });
     if (!Number.isSafeInteger(config.maxMessageBytes) || !Number.isSafeInteger(config.maxPendingBytes)) {
         throw new TypeError('STOMP byte capacities must be safe integers');
     }

package/src/infrastructure/streams/stompSource.js

@@ -85,7 +85,7 @@ async function deliver(ctx, body) {
   try {
     await deadline(Promise.resolve().then(() => {
       return acceptStomp(ctx, body, settle);
-    }), ctx.lifecycle.acceptTimeoutMs, 'STOMP acceptance', (error) => {
+    }), ctx.lifecycle.deliveryTimeoutMs, 'STOMP acceptance', (error) => {
       ctx.lifecycle.fail(error);
     });
     if (!ctx.manualAck) {
@@ -139,6 +139,8 @@ function bind(channel, destination, collector, delivery) {
  * Messages are `{destination, payload, settle}`. Default ack-after-accept;
  * with `manualAck` the collector owns settle. Arrivals enqueue in
  * subscribe order. With `serial: false` persist may overlap after enqueue.
+ * deliveryTimeoutMs optionally includes bounded collector queue wait; body reads
+ * retain acceptTimeoutMs. Collectors owning an execution deadline can separate them.
  * A finite prefetch (default 32) bounds unacknowledged broker deliveries.
  *
  * @param {string} url - STOMP broker URL