fix: stop dropping analytics instances larger than ~100k rows (#87)

`downloadInstanceRows` appended parsed rows with `rows.push(...parseTsv(tsv))`.
The spread passes every row as a separate argument, so once an instance holds
roughly 100k+ rows the call exceeds the engine's argument-count limit and
throws "RangeError: Maximum call stack size exceeded" (V8 reports the
argument-count limit under that message; it is not stack recursion).

The throw is caught by the `Promise.allSettled` handler in `fetchReportData`,
which logs "instance download failed (data may be incomplete)" and skips the
instance. Sync still reports success, so the report silently loses that
instance's history.

ONE_TIME_SNAPSHOT instances carry an app's whole history in one segment and
routinely exceed the limit. On a real account this dropped every historical
instance for the high-cardinality reports while the low-volume ones were
unaffected:

  App Downloads              10 dates ->  636 dates (343,904 rows)
  Discovery and Engagement   11 dates ->  637 dates (398,161 rows)
  Installation and Deletion  13 dates ->  634 dates (210,623 rows)
  Sessions                  636 dates ->  636 dates (unchanged, 85,039 rows)

Replace both spreads with a `pushAll` helper that appends element by element.
The same pattern was used when appending a single date's rows to the deduped
array, so that call site is changed too.

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: yaaayaaa

src/lib/asc/analytics-reports.ts

@@ -8,6 +8,7 @@ import {
   PERF_METRICS_TTL,
   findDateGaps,
   parseTsv,
+  pushAll,
   type AscReportRequest,
   type AscReport,
   type AscReportInstance,
@@ -346,7 +347,9 @@ async function downloadInstanceRows(
   const rows: Array<Record<string, string>> = [];
   for (const seg of segResp.data) {
     const tsv = await downloadSegment(seg.attributes.url);
-    rows.push(...parseTsv(tsv));
+    // pushAll, not push(...): snapshot instances can hold 300k+ rows, which
+    // exceeds the engine's argument-count limit when spread into push().
+    pushAll(rows, parseTsv(tsv));
   }
   return rows;
 }
@@ -498,7 +501,9 @@ export async function fetchReportData(
     for (const [date, rows] of rowsByDate) {
       if (!seenDataDates.has(date)) {
         seenDataDates.add(date);
-        deduped.push(...rows);
+        // Same argument-count limit as above – a single date can hold enough
+        // rows to exceed it once territory/source/version dimensions multiply.
+        pushAll(deduped, rows);
       }
     }
   }

src/lib/asc/analytics-types.ts

@@ -126,6 +126,20 @@ export function parseTsv(raw: string): Array<Record<string, string>> {
   });
 }
 
+/**
+ * Append every element of `source` to `target`.
+ *
+ * Use this instead of `target.push(...source)`: the spread passes each element
+ * as a separate argument, so it exceeds the engine's argument-count limit once
+ * `source` holds roughly 100k+ elements. V8 reports that as
+ * "RangeError: Maximum call stack size exceeded", which is misleading – it is
+ * an argument-count limit, not stack recursion. Analytics snapshot instances
+ * routinely exceed it (a single App Downloads instance can hold 300k+ rows).
+ */
+export function pushAll<T>(target: T[], source: readonly T[]): void {
+  for (const item of source) target.push(item);
+}
+
 // ---------- Helpers ----------
 
 export function emptyAnalyticsData(): AnalyticsData {

tests/unit/asc/analytics-types.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from "vitest";
+import { pushAll } from "@/lib/asc/analytics-types";
+
+describe("pushAll", () => {
+  it("appends every element, preserving order", () => {
+    const target = [1, 2];
+    pushAll(target, [3, 4, 5]);
+    expect(target).toEqual([1, 2, 3, 4, 5]);
+  });
+
+  it("is a no-op for an empty source", () => {
+    const target = [1];
+    pushAll(target, []);
+    expect(target).toEqual([1]);
+  });
+
+  it("handles sources far beyond the spread argument-count limit", () => {
+    // `target.push(...source)` throws "RangeError: Maximum call stack size
+    // exceeded" somewhere above ~100k elements because each element becomes a
+    // separate argument. Analytics snapshot instances routinely exceed that.
+    const source = Array.from({ length: 200_000 }, (_, i) => i);
+    const target: number[] = [];
+
+    pushAll(target, source);
+
+    expect(target).toHaveLength(200_000);
+    expect(target[0]).toBe(0);
+    expect(target[199_999]).toBe(199_999);
+  });
+});

tests/unit/asc/analytics.test.ts

@@ -4119,3 +4119,63 @@ describe("buildAnalyticsData – accumulation across refreshes", () => {
     expect(consoleLogSpy).not.toHaveBeenCalledWith(expect.stringContaining("Backfill app-nogap"));
   });
 });
+
+describe("large snapshot instances", () => {
+  it("ingests an instance whose row count exceeds the spread argument limit", async () => {
+    mockCacheGet.mockReturnValue(null);
+    // The console spies are shared across the file and keep earlier tests'
+    // calls, so clear before asserting on what this test logs.
+    consoleWarnSpy.mockClear();
+
+    // A ONE_TIME_SNAPSHOT instance carries the app's whole history in one
+    // segment. Real accounts reach 300k+ rows; anything above roughly 100k
+    // used to be dropped by `rows.push(...parseTsv(tsv))` with
+    // "RangeError: Maximum call stack size exceeded", and the failure was only
+    // logged as a warning – the report silently lost that instance's history.
+    //
+    // Every row shares one data date, so the second call site (appending one
+    // date's rows to the deduped array) is exercised too — though only on the
+    // fixed code, since on main the first spread throws before reaching it.
+    const ROW_COUNT = 150_000;
+    const rows = Array.from({ length: ROW_COUNT }, () => [
+      "2026-02-01",
+      "First-time download",
+      "1",
+    ]);
+    const hugeTsv = tsvString(["Date", "Download Type", "Counts"], rows);
+
+    mockAscFetch.mockImplementation(async (url: string) => {
+      if (url.includes("/analyticsReportRequests") && !url.includes("/reports")) {
+        return reportRequestsResponse(["req-huge"]);
+      }
+      if (url.includes("/reports?filter")) {
+        return reportsResponse([
+          { id: "rpt-huge", name: "App Downloads Standard", category: "COMMERCE" },
+        ]);
+      }
+      if (url.includes("/instances?")) {
+        return instancesResponse([{ id: "inst-huge", processingDate: "2026-02-02" }]);
+      }
+      if (url.includes("/segments")) {
+        return segmentsResponse([{ id: "seg-huge", url: "https://s3.example.com/huge.tsv" }]);
+      }
+      return { data: [] };
+    });
+    mockFetch.mockResolvedValue(makeFetchResponse(hugeTsv));
+
+    const result = await buildAnalyticsData("app-huge-instance");
+
+    // Every row survives: no instance was skipped.
+    expect(result.dailyDownloads).toHaveLength(1);
+    expect(result.dailyDownloads[0]).toEqual({
+      date: "2026-02-01",
+      firstTime: ROW_COUNT,
+      redownload: 0,
+      update: 0,
+    });
+    expect(consoleWarnSpy).not.toHaveBeenCalledWith(
+      expect.stringContaining("instance download failed"),
+      expect.anything(),
+    );
+  });
+});