Durable Log Writer

Design and implement a Durable Log Writer that multiple threads can call concurrently to append records to a file on disk.

Requirements

1. Durability: Once write() returns to a caller, the record must survive a process crash or power loss.
2. High throughput: Support 100 000+ small (tens of bytes) writes per second on commodity SSDs.
3. Ordering: Records written by a single thread must appear in the same order in the file.
4. Atomic batching: Many concurrent threads may be writing; you must batch their data together and perform only one fsync for the entire batch (group-commit).
5. Crash recovery: On restart the library must be able to replay the file and return only the valid prefix of records; any partial or corrupted data at the tail must be detected and truncated.

API to implement

class DurableLogWriter {
    // Create or open the log file at `path` and optionally run recovery.
    DurableLogWriter(Path path, boolean recover) throws IOException;

    // Append `data` to the log and return only after the record is durable.
    // This call must be thread-safe.
    void write(byte[] data) throws IOException;

    // Close the log file.
    void close() throws IOException;

    // Return an iterator over all valid records in the file (used for recovery).
    Iterator<byte[]> iterator() throws IOException;
}

Record format you must use
Each record is laid out as:
[4 bytes length][variable data][4 bytes CRC32 of data]
The length field lets readers skip to the next record; the CRC lets readers detect corruption and stop at the first invalid record.