@aikidosec/broker-client 1.0.10 → 1.0.12

package/app/streaming/flowControl.js

@@ -14,11 +14,11 @@ export function pauseStreamIfOverLimit(requestId, stream) {
   const state = activeStreams.get(requestId);
   if (!state || state.paused) return;
   
-  const shouldPause = totalBufferSize() >= GLOBAL_MAX_BUFFER_SIZE || state.buffer.length >= PER_STREAM_MAX_BUFFER_SIZE;
+  const shouldPause = totalBufferSize() >= GLOBAL_MAX_BUFFER_SIZE || state.bufferedBytes >= PER_STREAM_MAX_BUFFER_SIZE;
   if (shouldPause) {
     state.paused = true;
     stream.pause();
-    log.info(`Stream paused for ${requestId}, stream buffer: ${(state.buffer.length / (1024 * 1024)).toFixed(2)} MB, global: ${(totalBufferSize() / (1024 * 1024)).toFixed(2)} MB`);
+    log.info(`Stream paused for ${requestId}, stream buffer: ${(state.bufferedBytes / (1024 * 1024)).toFixed(2)} MB, global: ${(totalBufferSize() / (1024 * 1024)).toFixed(2)} MB`);
   }
 }
 
@@ -30,10 +30,10 @@ export function resumePausedStreams() {
   if (totalBufferSize() >= GLOBAL_MAX_BUFFER_SIZE) return;
   
   for (const [requestId, state] of activeStreams.entries()) {
-    if (state.paused && !state.complete && state.buffer.length < PER_STREAM_MAX_BUFFER_SIZE) {
+    if (state.paused && !state.complete && state.bufferedBytes < PER_STREAM_MAX_BUFFER_SIZE) {
       state.paused = false;
       state.stream.resume();
-      log.info(`Stream resumed for ${requestId} after cleanup, stream buffer: ${(state.buffer.length / (1024 * 1024)).toFixed(2)} MB, global: ${(totalBufferSize() / (1024 * 1024)).toFixed(2)} MB`);
+      log.info(`Stream resumed for ${requestId} after cleanup, stream buffer: ${(state.bufferedBytes / (1024 * 1024)).toFixed(2)} MB, global: ${(totalBufferSize() / (1024 * 1024)).toFixed(2)} MB`);
     }
   }
 }

package/app/streaming/handlers.js

@@ -78,7 +78,7 @@ async function waitForData(state) {
   const checkIntervalMs = 100;
   let waited = 0;
   
-  const hasEnoughData = () => state.buffer.length >= STREAM_CHUNK_SIZE;
+  const hasEnoughData = () => state.bufferedBytes >= STREAM_CHUNK_SIZE;
   const isStreamDone = () => state.complete || state.error;
   const hasTimedOut = () => waited >= maxWaitMs;
   
@@ -89,42 +89,77 @@ async function waitForData(state) {
 }
 
 /**
- * Extract a chunk from the buffer and manage buffer state
+ * Extract a chunk from the buffer queue and manage buffer state
  */
 function extractChunkFromBuffer(state, requestId) {
-  let chunkData;
   let isComplete = false;
+  let bytesToExtract;
   
-  if (state.buffer.length >= STREAM_CHUNK_SIZE) {
-    // Have enough data for a full chunk
-    chunkData = state.buffer.slice(0, STREAM_CHUNK_SIZE);
-    state.buffer = state.buffer.slice(STREAM_CHUNK_SIZE);
-    subtractFromTotalBuffer(chunkData.length);
-    
-    // Resume stream if it was paused and both limits are now satisfied
-    resumeStreamIfBelowBufferLimits(state);
+  if (state.bufferedBytes >= STREAM_CHUNK_SIZE) {
+    bytesToExtract = STREAM_CHUNK_SIZE;
   } else if (state.complete) {
-    // Stream is done, send remaining buffer
-    chunkData = state.buffer;
-    subtractFromTotalBuffer(chunkData.length);
-    state.buffer = Buffer.alloc(0);
+    bytesToExtract = state.bufferedBytes;
     isComplete = true;
   } else {
     // Timeout waiting for data - send what we have
-    log.warn(`get_next_chunk: Timeout waiting for data for ${requestId}, sending ${state.buffer.length} bytes`);
-    chunkData = state.buffer;
-    subtractFromTotalBuffer(chunkData.length);
-    state.buffer = Buffer.alloc(0);
+    log.warn(`get_next_chunk: Timeout waiting for data for ${requestId}, sending ${state.bufferedBytes} bytes`);
+    bytesToExtract = state.bufferedBytes;
+  }
+  
+  const chunkData = extractBytesFromQueue(state, bytesToExtract);
+  subtractFromTotalBuffer(chunkData.length);
+  
+  // Resume stream if it was paused and both limits are now satisfied
+  if (!isComplete) {
+    resumeStreamIfBelowBufferLimits(state);
   }
   
   return { chunkData, isComplete };
 }
 
+/**
+ * Extract exact number of bytes from buffer queue.
+ * 
+ * Efficiency: The queue contains many small buffers (~64KB each from internal resource).
+ * We take whole buffers by reference (no copy) and only slice the last partial buffer.
+ * Final concat is O(n) for extracted buffers only, not the entire queue.
+ * 
+ * Example: To extract 10MB from [64KB, 64KB, 64KB, ...] (156 buffers):
+ *   - shift() 155 whole buffers (just pointer moves, no copying)
+ *   - slice() 1 partial buffer
+ *   - concat() once at the end (single 10MB allocation)
+ */
+function extractBytesFromQueue(state, bytesToExtract) {
+  if (bytesToExtract === 0) return Buffer.alloc(0);
+  
+  const extracted = [];
+  let extractedBytes = 0;
+  
+  while (extractedBytes < bytesToExtract && state.buffers.length > 0) {
+    const buf = state.buffers[0];
+    const needed = bytesToExtract - extractedBytes;
+    
+    if (buf.length <= needed) {
+      // Take entire buffer
+      extracted.push(state.buffers.shift());
+      extractedBytes += buf.length;
+    } else {
+      // Take partial buffer
+      extracted.push(buf.slice(0, needed));
+      state.buffers[0] = buf.slice(needed);
+      extractedBytes += needed;
+    }
+  }
+  
+  state.bufferedBytes -= extractedBytes;
+  return Buffer.concat(extracted);
+}
+
 /**
  * Resume a paused stream if buffer limits allow
  */
 function resumeStreamIfBelowBufferLimits(state) {
-  const canResume = totalBufferSize() < GLOBAL_MAX_BUFFER_SIZE && state.buffer.length < PER_STREAM_MAX_BUFFER_SIZE;
+  const canResume = totalBufferSize() < GLOBAL_MAX_BUFFER_SIZE && state.bufferedBytes < PER_STREAM_MAX_BUFFER_SIZE;
   if (state.paused && canResume) {
     state.paused = false;
     state.stream.resume();

package/app/streaming/initStreamingResponse.js

@@ -22,7 +22,8 @@ export function initStreamingResponse({ requestId, statusCode, headers, stream,
   // Store stream state for pull-based retrieval
   const streamState = {
     stream,
-    buffer: Buffer.alloc(0),
+    buffers: [],        // Queue of buffers - O(1) append
+    bufferedBytes: 0,   // Total bytes across all buffers
     complete: false,
     error: null,
     totalBytesSent: 0,
@@ -34,7 +35,9 @@ export function initStreamingResponse({ requestId, statusCode, headers, stream,
   activeStreams.set(requestId, streamState);
   
   // Buffer data as it arrives from the internal resource
-  // Use bounded buffering with global and per-stream limits to control memory usage
+  // Incoming chunks are small (typically 16-64KB from OS/Node.js TCP buffers)
+  // We accumulate them in an array and only concat when sending 10MB chunks to server
+  // This avoids O(n²) memory copying that would occur with Buffer.concat on every chunk
   stream.on('data', (chunk) => {
     // Yield to event loop periodically to allow ping/pong processing
     // This prevents stream data from starving Socket.IO heartbeats
@@ -45,7 +48,8 @@ export function initStreamingResponse({ requestId, statusCode, headers, stream,
         return;
       }
       
-      state.buffer = Buffer.concat([state.buffer, chunk]);
+      state.buffers.push(chunk);
+      state.bufferedBytes += chunk.length;
       addToTotalBuffer(chunk.length);
       
       // Pause stream if buffer limits exceeded (backpressure)
@@ -57,7 +61,7 @@ export function initStreamingResponse({ requestId, statusCode, headers, stream,
     const state = activeStreams.get(requestId);
     if (state) {
       state.complete = true;
-      log.info(`Stream ended for request ${requestId}, ${(state.buffer.length / (1024 * 1024)).toFixed(2)} MB remaining in buffer`);
+      log.info(`Stream ended for request ${requestId}, ${(state.bufferedBytes / (1024 * 1024)).toFixed(2)} MB remaining in buffer`);
     }
   });
   

package/app/streaming/state.js

@@ -3,19 +3,29 @@
  */
 
 // Chunk size for streaming responses (10MB before base64 encoding)
-export const STREAM_CHUNK_SIZE = 30 * 1024 * 1024;
+export const STREAM_CHUNK_SIZE = 10 * 1024 * 1024;
 
 // Global maximum buffer size across ALL streams
-export const GLOBAL_MAX_BUFFER_SIZE = STREAM_CHUNK_SIZE * 30; // 900MB
+export const GLOBAL_MAX_BUFFER_SIZE = STREAM_CHUNK_SIZE * 30; // 300MB
 
 // Per-stream maximum buffer size
-export const PER_STREAM_MAX_BUFFER_SIZE = STREAM_CHUNK_SIZE * 5; // 150MB
+export const PER_STREAM_MAX_BUFFER_SIZE = STREAM_CHUNK_SIZE * 1.5; // 15MB
 
 // Threshold for using streaming vs direct response
 export const STREAMING_THRESHOLD = STREAM_CHUNK_SIZE;
 
 // Active streams for pull-based streaming (server pulls chunks from client)
-// Key: request_id, Value: { stream, buffer, complete, error, totalBytesSent, chunkIndex, paused, lastActivity }
+// Key: request_id, Value: { stream, buffers, bufferedBytes, complete, error, totalBytesSent, chunkIndex, paused, lastActivity }
+//
+// Buffer structure:
+//   - buffers[]: Array of small Buffer chunks received from the internal resource (e.g., API, database)
+//                Typical chunk size: 16-64KB (depends on OS TCP buffers and Node.js stream settings)
+//   - bufferedBytes: Total bytes across all buffers (avoids O(n) length calculation)
+//
+// Data flow:
+//   Internal Resource → HTTP stream → small chunks (16-64KB) → buffers[]
+//   When server requests: extract from buffers[] → concat to 10MB chunk → send via Socket.IO
+//
 export const activeStreams = new Map();
 
 // Track total buffer size across all streams
@@ -61,9 +71,7 @@ export function subtractFromTotalBuffer(bytes) {
 export function recalculateTotalBufferSize() {
   let actual = 0;
   for (const [, state] of activeStreams.entries()) {
-    if (state.buffer) {
-      actual += state.buffer.length;
-    }
+    actual += state.bufferedBytes || 0;
   }
   
   if (actual !== _totalBufferSize) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aikidosec/broker-client",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "description": "Aikido Broker Client - Runs in customer network to forward requests to internal resources",
   "main": "app/client.js",
   "type": "module",