Log File Chunker

Upload forms, message brokers, and APIs enforce byte budgets, and a giant log file stops dead at the first one. Log File Chunker cuts any log into chunks that fit a target byte size you choose — 4 MB for an upload form, 256 KB for a queue, 64 KB for an API — measuring real UTF-8 bytes and keeping each chunk at or under the limit.

Two packing strategies cover every case. Hard split packs the file to the very last byte using a binary search on the cut point for every chunk, splitting mid-line when necessary so the minimum possible number of chunks is produced, which matters when a strict byte ceiling is more important than keeping a line intact. Line-safe mode stops only at line boundaries: it accumulates whole lines into the current chunk and closes it the moment the next line would push it over budget, then warns if any single line is longer than the budget itself, since a line-safe chunk cannot be forced to split that line. Either way, every chunk is measured against the same budget, and concatenating the chunks back together in order reproduces the original file byte for byte, including any mid-line cut points from hard mode.

Each chunk in the results list shows its exact byte count next to a fill bar sized against the chosen budget, so it is immediately obvious how close a given chunk came to the limit rather than just that it fits somewhere under it. Chunks with room to spare read as a short bar; chunks packed close to the ceiling read as nearly full. Copy or download buttons sit on every chunk individually, plus a single Download all action that walks the whole list.

• Hard byte budget — set the chunk size in KB, matched against real UTF-8 byte length rather than character count.
• Hard split mode — packs each chunk to the last byte using a binary-search cut point, splitting a line if needed to hit the minimum chunk count.
• Line-safe mode — keeps every line whole and closes a chunk before the next line would overflow it, with an explicit warning when a single line is larger than the budget.
• True UTF-8 sizing — multi-byte characters, emoji, and accented text are counted as the bytes they actually are, not as one character each.
• Per-chunk byte report — every chunk lists its exact size and line count, with a fill bar scaled to the budget so near-full chunks are obvious at a glance.
• Byte-exact reassembly — concatenating the chunks in order restores the original file exactly, mid-line splits included.
• Per-chunk and bulk export — copy or download any single chunk, or download every chunk in one click.
• 100% local — nothing leaves the browser, no upload, no server round trip.

1. Paste your log into the text box, or click Load sample to see the tool work on a small multi-line example first.
2. Set the chunk size in KB — pick a number comfortably under the hard limit of whatever system receives the chunks.
3. Pick a packing mode. Line-safe keeps every line whole and is the safer default for anything that gets parsed line by line; hard split packs to the last byte and is the right choice when the byte ceiling is absolute.
4. Click Chunk log. Every chunk is listed with its exact byte size, line count, and a fill bar relative to the budget.
5. Watch for the oversized-line warning in line-safe mode — it means at least one line alone exceeds the budget and could not be split, so that chunk runs over on its own.
6. Export. Copy or download any single chunk from its own panel, or use Download all to grab every piece in one pass.

Example 1 — 4 MB upload form. An importer rejects attachments over 4 MB. Chunking with a 4,000 KB budget in hard mode turns a large export into a handful of safely sized files that upload one after another.

Example 2 — 256 KB queue messages. A data-pipeline queue caps each message at 256 KB. Chunking in line-safe mode keeps every payload intact and under budget, so the consumer on the other end never has to reassemble a broken line.

Example 3 — 64 KB API calls. A diagnostics API accepts at most 64 KB per request. A 500 KB trace becomes eight budget-compliant pieces that reassemble perfectly once posted in order.

Example 4 — Non-ASCII logs. A log stream tags entries with emoji and accented service names. Because the chunker measures real UTF-8 bytes, a 64 KB budget never silently overflows once multi-byte characters are counted honestly.

• Guaranteed at-or-under-budget chunks — every size is byte-accounted against real UTF-8 length, not estimated from character count.
• Two packing strategies — maximum density when the byte ceiling is absolute, or line-safe when every line must stay parsable on its own.
• Byte-exact round trip — nothing is lost, reordered, or duplicated when the chunks are concatenated back together.
• Fits any pipeline — uploads, message queues, framed APIs, or email attachment limits.
• Instant visual budget check — the per-chunk fill bar shows how close each piece came to the limit.
• Private — all chunking happens locally in the browser; nothing is ever transmitted.