chore: drop per-batch size chunking to match upstream uploader

The 256 KB ceiling I added speculatively when the server cap was 256 KB
no longer matches the reference implementation we're mirroring, which
sends each flush as a single POST regardless of size. With the server
cap now well above any plausible single-flush volume, chunking is
unnecessary and divergent — drop it.

Removes _chunk_by_size, _MAX_BATCH_BYTES, and the four chunking tests.
_flush now POSTs the entire buffered batch as one request.

Author: barslev

socketsecurity/core/log_uploader.py

@@ -26,8 +26,6 @@
 
 _FLUSH_GUARD = threading.local()
 
-_MAX_BATCH_BYTES = 256 * 1024 - 1024  # depscan body cap is 256KB; reserve headroom for envelope/headers
-
 _LEVEL_MAP = {
     logging.DEBUG: "DEBUG",
     logging.INFO: "INFO",
@@ -88,48 +86,22 @@ def _flush(self) -> None:
         with self._lock:
             if not self._buf:
                 return
-            entries = self._buf
+            batch = self._buf
             self._buf = []
 
         _FLUSH_GUARD.active = True
         try:
-            for chunk in _chunk_by_size(entries):
-                try:
-                    self._client.request(
-                        path=f"python-cli-runs/{self._run_id}/logs",
-                        method="POST",
-                        payload=json.dumps({"logs": chunk}),
-                    )
-                except Exception as e:
-                    log.debug(f"log upload failed (swallowed, {len(chunk)} entries dropped): {e}")
+            self._client.request(
+                path=f"python-cli-runs/{self._run_id}/logs",
+                method="POST",
+                payload=json.dumps({"logs": batch}),
+            )
+        except Exception as e:
+            log.debug(f"log upload failed (swallowed, {len(batch)} entries dropped): {e}")
         finally:
             _FLUSH_GUARD.active = False
 
 
-def _chunk_by_size(entries: list) -> list:
-    """Split entries into chunks that each serialize to <= _MAX_BATCH_BYTES.
-    Single entries that exceed the cap are dropped with a debug log."""
-    chunks: list = []
-    current: list = []
-    envelope = len('{"logs":[]}')
-    current_size = envelope
-    for entry in entries:
-        entry_size = len(json.dumps(entry)) + 1  # +1 for inter-entry comma
-        if entry_size + envelope > _MAX_BATCH_BYTES:
-            log.debug(f"log entry too large ({entry_size}B), dropped")
-            continue
-        if current and current_size + entry_size > _MAX_BATCH_BYTES:
-            chunks.append(current)
-            current = [entry]
-            current_size = envelope + entry_size
-        else:
-            current.append(entry)
-            current_size += entry_size
-    if current:
-        chunks.append(current)
-    return chunks
-
-
 class UploadingLogHandler(logging.Handler):
     def __init__(self, uploader: BatchedLogUploader, context: str = "socket-python-cli"):
         super().__init__()

tests/unit/test_log_uploader.py

@@ -8,10 +8,8 @@
 from socketsecurity.core.cli_client import CliClient
 from socketsecurity.core.exceptions import APIFailure
 from socketsecurity.core.log_uploader import (
-    _MAX_BATCH_BYTES,
     BatchedLogUploader,
     UploadingLogHandler,
-    _chunk_by_size,
 )
 from socketsecurity.core.socket_config import SocketConfig
 
@@ -140,49 +138,6 @@ def test_levels_map_correctly():
     assert levels == ["DEBUG", "INFO", "WARN", "ERROR", "ERROR"]
 
 
-def test_chunk_by_size_keeps_small_batches_intact():
-    entries = [{"timestamp": "t", "level": "INFO", "message": "x", "context": "c"}] * 5
-    chunks = _chunk_by_size(entries)
-    assert len(chunks) == 1
-    assert chunks[0] == entries
-
-
-def test_chunk_by_size_splits_when_exceeding_cap():
-    big_msg = "y" * 1000
-    entries = [
-        {"timestamp": "2026-05-07 22:30:00.000", "level": "INFO",
-         "message": big_msg, "context": "c"}
-        for _ in range(500)
-    ]
-    chunks = _chunk_by_size(entries)
-    assert len(chunks) >= 2
-    for chunk in chunks:
-        size = len(json.dumps({"logs": chunk}))
-        assert size <= _MAX_BATCH_BYTES
-    assert sum(len(c) for c in chunks) == len(entries)
-
-
-def test_chunk_by_size_drops_single_oversize_entry():
-    too_big = {"timestamp": "t", "level": "INFO",
-               "message": "z" * (_MAX_BATCH_BYTES + 100), "context": "c"}
-    ok = {"timestamp": "t", "level": "INFO", "message": "ok", "context": "c"}
-    chunks = _chunk_by_size([ok, too_big, ok])
-    flat = [e for c in chunks for e in c]
-    assert flat == [ok, ok]  # too_big dropped, smalls preserved
-
-
-def test_flush_chunks_oversize_buffer_into_multiple_posts():
-    client = Mock(spec=CliClient)
-    u = BatchedLogUploader(client, "run-c", flush_interval=10)
-    big_msg = "y" * 1000
-    for _ in range(500):
-        u.add({"timestamp": "2026-05-07 22:30:00.000", "level": "INFO",
-               "message": big_msg, "context": "c"})
-
-    u._flush()
-    assert client.request.call_count >= 2  # split into multiple POSTs
-
-
 def test_run_thread_flushes_periodically_then_exits():
     client = Mock(spec=CliClient)
     u = BatchedLogUploader(client, "run-t", flush_interval=0.05)