Log Integrity Checker

A log is only trustworthy if its timeline is intact. Rotation gaps, buffered replay, clock skew, and dropped records all leave fingerprints in the sequence of timestamps, and those fingerprints are easy to miss when you are scrolling through thousands of lines by eye. Log Integrity Checker walks a log and verifies the timeline mechanically, reporting four classes of problems: timestamps out of order, timestamps that are missing entirely, duplicate timestamps, and gaps larger than the maximum interval you define. Instead of trusting that a log is complete because it looks plausible, you get a concrete answer.

Give it your expected spacing between lines in seconds and the tool walks consecutive pairs of timestamped lines, measuring every gap, flagging every inversion, and listing every line that could not produce a timestamp at all. Order checks compare each timestamp against the one before it and flag anything earlier, which is exactly what happens when two writers interleave into the same file, when a buffered batch replays after the fact, or when a clock jumps backward. Duplicate checks catch consecutive identical timestamps, which usually means a retry loop fired twice or the same record was replayed. Missing-timestamp checks catch any line the timestamp pattern cannot match, whether that is a stack-trace continuation line, a malformed record, or a different log format mixed into the file.

Gap detection is the check most people reach for first, because it answers "did we lose records?" Set the maximum interval you expect between consecutive lines — a few seconds for a chatty service, an hour for a quiet cron job — and any larger gap is reported with its exact size and the lines bracketing the jump. The report separates each problem class with exact line numbers, so the story of what corrupted the stream is easy to read and hand off: "line 4021, gap of 340s" is something you can act on immediately. Every check runs entirely in your browser against the text you paste in.

• Chronological-order check — find inverted timestamps caused by writer skew or replay.
• Gap detection — flag missing records between consecutive lines against a configurable max interval.
• Duplicate detection — catch repeated identical timestamps from retries or re-fed batches.
• Missing-timestamp detection — surface every line that the pattern fails to match.
• Configurable timestamp pattern and max interval — adapt to any format and cadence, or disable gap checks with 0.
• Toggleable duplicate check — turn off duplicate flagging when your data legitimately repeats timestamps.
• Per-class summary stats — counts for lines scanned, out-of-order, gaps, and missing timestamps.
• Line-numbered report — every issue lists its exact line number and the offending text.
• Copy report — take the findings straight into a ticket.
• 100% local — nothing leaves the browser.

1. Paste your log into the text box, timestamps and all.
2. Set the timestamp pattern if your format is not ISO-8601 — the default expects YYYY-MM-DD followed by T or a space and HH:MM:SS.
3. Set the max interval between lines in seconds; this defines how large a gap has to be before it is flagged. Use 0 to disable gap checking entirely.
4. Choose whether to flag duplicates if your log format is expected to repeat identical timestamps on adjacent lines.
5. Check integrity. The timeline is scanned line by line for each problem class in a single pass.
6. Review the summary cards for a quick count of lines scanned, out-of-order lines, gaps, and missing timestamps.
7. Read the categorized report with exact line numbers, and copy it into a ticket or incident notes.

Example 1 — Gap audit. A retention pipeline silently drops records during a nightly compaction job. Set the expected interval to match the service’s normal write cadence and the checker lists every place the timeline jumps further than that, with the exact gap size and bracketing line numbers.

Example 2 — Replay detection. A message queue redelivers a batch after a consumer restart. Duplicate timestamps reveal exactly which records were re-fed.

Example 3 — Writer skew. Two processes append to the same log file without coordinating, and their lines interleave. Out-of-order timestamps expose precisely where one writer’s line lands ahead of the other’s, which is nearly impossible to spot by eye in a long file.

Example 4 — Format drift. A rotation script accidentally mixes two timestamp formats into one file. Lines in the unexpected format are reported as missing timestamps instead of being silently ignored.

• Timeline trust — verify the stream you depend on before you rely on it for an investigation.
• Four problem classes in one pass — gaps, order, duplicates, and missing timestamps checked together.
• Exact line locations — jump straight to the damage instead of scrolling and guessing.
• Configurable tolerances — the max interval and timestamp pattern fit your log’s own cadence and format.
• Fast triage — summary counts tell you at a glance whether a log is healthy before you read a single issue line.
• Private — all processing stays local, nothing is ever uploaded.