chunk() never resets its size counter: past 500 KB every queued event is uploaded as its own request

El error está en la función chunk en packages/core/src/util.ts. Comience leyendo la función y el ayudante sizeOf. El issue incluye un caso de reproducción y una solución sugerida. Pruebe la solución ejecutando las pruebas existentes para la lógica de fragmentación (chunking), o cree una pequeña prueba para verificar que el comportamiento corregido devuelva los 20 fragmentos esperados en lugar de miles. Busque cualquier prueba relacionada en el repositorio.

Summary

chunk() in packages/core/src/util.ts never resets rollingKBSize. Once the queue's running size reaches maxKB (MAX_PAYLOAD_SIZE_IN_KB = 500), every later event goes into its own chunk. SegmentDestination.sendEvents then uploads all chunks at once with Promise.all, so a single flush sends one HTTP request per queued event.

if (maxKB !== undefined) {
  rollingKBSize += sizeOf(item);
  if (rollingKBSize >= maxKB) {
    chunks[++currentChunk] = [item];   // rollingKBSize is never reset
    return chunks;
  }
}

Reproduction

chunk(events, 1000, 500) with 10,000 events of about 1 KB each returns 9,481 chunks: one of 520 events, then 9,480 of one event each. The expected result is 20 chunks of about 520.

Impact

It shows up when the queue grows past 500 KB, which happens when uploads keep failing (for example, a device whose DNS blocks *.segmentapis.com). The queue persists across launches. If cdn-settings.segment.com is unreachable too, there's no httpConfig, so no backoff and no maxTotalBackoffDuration pruning, and maxQueueSize isn't enforced anywhere. In production we saw one iOS session make about 9,700 upload attempts in 91 seconds, at a steady ~60 per second (URLSession's 6 connections per host).

Version: 2.24.1. Same code on master.

Suggested fix

Keep a size counter per chunk and reset it when a new chunk starts, and push chunks instead of assigning by index. That also fixes the sparse-array case in #1309.

export const chunk = <T>(array: T[], count: number, maxKB?: number): T[][] => {
  if (!array.length || !count) return [];
  const result: T[][] = [];
  let current: T[] = [];
  let currentKB = 0;
  for (const item of array) {
    const itemKB = maxKB !== undefined ? sizeOf(item) : 0;
    const isFull = current.length >= count || (maxKB !== undefined && currentKB + itemKB >= maxKB);
    if (current.length > 0 && isFull) {
      result.push(current);
      current = [];
      currentKB = 0;
    }
    current.push(item);
    currentKB += itemKB;
  }
  if (current.length > 0) result.push(current);
  return result;
};