rust-py-audit 0.3.3__tar.gz → 0.4.2__tar.gz

{rust_py_audit-0.3.3 → rust_py_audit-0.4.2}/.github/workflows/release.yml

@@ -141,21 +141,31 @@ jobs:
           path: dist
 
   macos:
+    # Um job só, os dois targets: o runner `macos-latest` é ARM e compila o
+    # x86_64 de forma cruzada. Antes era uma matriz de dois jobs, e cada
+    # release precisava de DUAS máquinas macOS — a fila mais disputada do
+    # GitHub Actions. Em 20/10/2026 dois releases (monitor 0.5.0, audit 0.4.1)
+    # ficaram parados com "The job was not acquired by Runner of type hosted
+    # even after multiple attempts" à espera da segunda.
     runs-on: macos-latest
     if: startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch'
     needs: [test, lint]
-    strategy:
-      matrix:
-        target: [x86_64, aarch64]
     steps:
       - uses: actions/checkout@v4
-      - uses: PyO3/maturin-action@v1
+      - name: Build wheels (x86_64)
+        uses: PyO3/maturin-action@v1
         with:
-          target: ${{ matrix.target }}
+          target: x86_64
           args: --release --out dist --find-interpreter
-      - uses: actions/upload-artifact@v4
+      - name: Build wheels (aarch64)
+        uses: PyO3/maturin-action@v1
+        with:
+          target: aarch64
+          args: --release --out dist --find-interpreter
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
         with:
-          name: wheels-macos-${{ matrix.target }}
+          name: wheels-macos
           path: dist
 
   sdist:

{rust_py_audit-0.3.3 → rust_py_audit-0.4.2}/.gitignore

@@ -9,3 +9,7 @@ build/
 *.pyd
 .pytest_cache/
 *.jsonl
+*.jsonl.lock
+
+# macOS
+.DS_Store

{rust_py_audit-0.3.3 → rust_py_audit-0.4.2}/CHANGELOG.md

@@ -5,6 +5,80 @@ Todas as mudanças relevantes deste projeto são registradas aqui.
 O formato segue [Keep a Changelog](https://keepachangelog.com/pt-BR/1.1.0/),
 e o versionamento segue [SemVer](https://semver.org/lang/pt-BR/).
 
+## [0.4.2] — não publicada
+
+Só CI: nada muda no comportamento da biblioteca nem nas wheels publicadas.
+
+### Alterado
+
+- **Build macOS num job só.** O `release.yml` compilava `x86_64` e `aarch64`
+  numa matriz de dois jobs, e cada release precisava de duas máquinas macOS —
+  a fila mais disputada do GitHub Actions. Em 20/10/2026 dois releases
+  (`rust-py-monitor` 0.5.0 e `rust-py-audit` 0.4.1) ficaram parados com «The
+  job was not acquired by Runner of type hosted even after multiple attempts»
+  esperando a segunda máquina. Agora um único job em `macos-latest` (ARM)
+  compila os dois targets — o `x86_64` de forma cruzada, como já era feito —
+  e sobe um artefato `wheels-macos`. As wheels geradas são as mesmas.
+
+## [0.4.1] — não publicada
+
+Resposta ao incidente da CA eMudhra / emSign (outubro de 2026).
+
+### Segurança
+
+- **`webpki-roots` 1.0.8 → 1.0.10.** O cliente do ImmutableLog (`reqwest` com
+  `rustls-tls`) não usa o certifi nem o repositório de certificados do sistema:
+  as raízes confiáveis vêm do `webpki-roots`, **compiladas dentro da wheel**.
+  A 0.4.0 e anteriores embutiam a raiz **"emSign ECC Root CA - G3"**, removida
+  dos bundles de CA depois do comprometimento de chaves intermediárias da
+  eMudhra — confiar nela abre espaço para MITM na conexão com o ImmutableLog. A
+  1.0.10 remove essa raiz (e a "Atos TrustedRoot 2011") e acrescenta SECOM TLS
+  2024 e Telia TLS v3. Afeta só os modos `remote` e `hybrid`; `mode="local"`
+  não abre conexão nenhuma.
+- Atualizar `pip`/`certifi` no ambiente **não** corrige versões anteriores da
+  biblioteca: é preciso instalar a 0.4.1.
+
+## [0.4.0] — não publicada
+
+Cadeia de hashes segura com vários processos (**P2-4**).
+
+### Corrigido
+
+- **Vários workers no mesmo JSONL quebravam a cadeia.** Cada processo
+  encadeava no `last_hash` que tinha em memória; com gunicorn ou
+  `uvicorn --workers`, dois eventos saíam com o mesmo `previous_hash` e o
+  `verify()` acusava `broken_chain` num arquivo que ninguém adulterou. O modo
+  de falha era silencioso até alguém rodar `verify()`. Reproduzido na 0.3.3
+  com 4 processos × 50 eventos: `{'valid': False, 'error_index': 1,
+  'reason': 'broken_chain'}`. Na 0.4.0 o mesmo teste dá `valid: True` com os
+  200 eventos.
+
+### Adicionado
+
+- **Lock de arquivo entre processos** (`fs2`: `flock` no Unix, `LockFileEx` no
+  Windows) num `<file_path>.lock` ao lado do log — à parte, porque o
+  `flush_pending()` troca o JSONL por `rename` e um lock no próprio arquivo
+  ficaria preso ao inode antigo. Com o lock, o logger confere se o arquivo
+  cresceu desde o seu último append; se cresceu, relê o último hash **só do fim
+  do arquivo**. O handle do `.lock` fica aberto no logger, então o custo do
+  caminho comum não mudou (~29 µs por `log()`, medido antes e depois).
+- **`fsync`** no construtor (padrão `False`). Com `True`, o `log()` só volta
+  depois de o evento estar no disco. Custa ~3,3 ms por evento no macOS
+  (`F_FULLFSYNC`), por isso é opt-in.
+- A reescrita atômica do `flush_pending()` agora faz `sync_data` antes do
+  `rename`, para uma queda de energia não deixar o arquivo final truncado.
+
+### Compatibilidade
+
+- Nenhum parâmetro existente mudou. Aparece um arquivo `<file_path>.lock` ao
+  lado do JSONL nos modos `local`/`hybrid`.
+- Em `mode="hybrid"` com vários workers, a entrega ao ImmutableLog acontece
+  dentro do lock (o hash enviado depende do anterior), então os `log()` dos
+  workers passam a se serializar também no tempo de rede.
+- Arquivos já gravados por vários workers em versões anteriores continuam
+  falhando no `verify()` a partir do primeiro entrelaçamento — o que eles têm
+  é o defeito antigo, não um efeito desta versão.
+
 ## [0.3.3] — não publicada
 
 Correção do passo de verificação pós-upload introduzido na 0.3.2, mais o

{rust_py_audit-0.3.3 → rust_py_audit-0.4.2}/Cargo.lock

@@ -517,6 +517,16 @@ dependencies = [
  "percent-encoding",
 ]
 
+[[package]]
+name = "fs2"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9564fc758e15025b46aa6643b1b77d047d1a56a1aea6e01002ac0c7026876213"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
 [[package]]
 name = "futures-channel"
 version = "0.3.32"
@@ -1597,8 +1607,9 @@ dependencies = [
 
 [[package]]
 name = "rust_py_audit"
-version = "0.3.3"
+version = "0.4.2"
 dependencies = [
+ "fs2",
  "httpmock",
  "pyo3",
  "reqwest",
@@ -2352,9 +2363,9 @@ dependencies = [
 
 [[package]]
 name = "webpki-roots"
-version = "1.0.8"
+version = "1.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf85cb06032201fa7c6f829d7db5a7e5aa45bcc0655327713065f6f0576731bf"
+checksum = "1c1c8e20c8a38fc7d65abfe74eb7280e4aa667e8eec8bc84996d2874810748d9"
 dependencies = [
  "rustls-pki-types",
 ]

{rust_py_audit-0.3.3 → rust_py_audit-0.4.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rust_py_audit"
-version = "0.3.3"
+version = "0.4.2"
 edition = "2021"
 description = "Auditoria de eventos com cadeia de hashes (SHA-256) para apps Python, core em Rust via PyO3."
 license = "MIT"
@@ -60,6 +60,11 @@ time = { version = "0.3", features = ["formatting", "parsing", "serde-well-known
 # (OpenSSL via "native-tls") evita exigir libssl-dev/headers do sistema
 # em cada plataforma onde o wheel é compilado/distribuído.
 reqwest = { version = "0.12", default-features = false, features = ["blocking", "json", "rustls-tls"] }
+# fs2: lock de arquivo entre processos (`flock` no Unix, `LockFileEx` no
+# Windows). Serializa o append da cadeia quando vários workers (gunicorn,
+# uvicorn --workers) gravam no mesmo JSONL. `File::lock` da std resolveria,
+# mas só estabilizou no Rust 1.89 e a CI fixa 1.88.
+fs2 = "0.4"
 
 [dev-dependencies]
 # httpmock: servidor HTTP local de mentirinha, usado só em `cargo test`

{rust_py_audit-0.3.3 → rust_py_audit-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rust-py-audit
-Version: 0.3.3
+Version: 0.4.2
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Rust
@@ -54,7 +54,8 @@ Records audit events (`who did what, when, on which resource`) in a fast, struct
 - **`AuditLogger`** — simple API: `log(...)`, `verify()`, `last_hash()`
 - **Hash chain (SHA-256)** — each event embeds the hash of the previous event; altering any recorded event breaks the chain in a detectable way
 - **JSONL storage** — one event per line, append-only, no database required
-- **Thread-safe** — a single `AuditLogger` can be shared across threads (e.g. a multi-threaded WSGI server, or one middleware instance serving concurrent requests); the hash chain stays linear under concurrency
+- **Thread-safe and multi-process-safe** — share one `AuditLogger` across threads, or point several worker processes (gunicorn, `uvicorn --workers`) at the same file: a cross-process file lock keeps the hash chain linear (see [Multiple workers](#multiple-workers))
+- **Optional `fsync`** — `fsync=True` makes `log()` return only once the event is on disk, surviving a power loss
 - **Free-form `metadata`** — any JSON-serializable `dict` (IP, reason, request_id, etc.)
 - **FastAPI middleware** — automatically logs state-changing requests (POST/PUT/PATCH/DELETE)
 - **Django middleware** — same idea, supports WSGI and ASGI
@@ -143,6 +144,53 @@ If any event was edited, removed, or reordered:
 # or "reason": "broken_chain" (removed/reordered/forged event)
 ```
 
+### Multiple workers
+
+Several processes can write to the same `file_path` — the usual gunicorn /
+`uvicorn --workers N` setup with one `AuditLogger` (or middleware) per worker:
+
+```python
+# every worker
+audit = AuditLogger(app_name="billing-api", file_path="/var/log/billing/audit.jsonl")
+```
+
+Each append takes an exclusive file lock on `<file_path>.lock` (created next to
+the log; `flock` on Unix, `LockFileEx` on Windows). Holding it, the logger checks
+whether the file grew since its own last write — meaning another worker wrote —
+and, if so, re-reads the last hash from the **tail** of the file before chaining.
+A single process never pays for that re-read, and the lock costs microseconds.
+
+Before 0.4.0 each process chained onto the last hash it kept in memory, so two
+workers produced events with the same `previous_hash` and `verify()` reported
+`broken_chain` on a file nobody had tampered with. If you ran several workers on
+an older version, `verify()` on that file will fail at the first point where two
+workers interleaved; start a new file after upgrading.
+
+Notes:
+
+- The lock is advisory and needs a filesystem with working locks — a local disk,
+  not most NFS/SMB mounts.
+- In `mode="hybrid"` the network delivery happens inside the lock (the event's
+  hash, sent to ImmutableLog, depends on the previous one), so concurrent
+  `log()` calls across workers serialize on delivery time too — bounded by
+  `timeout_ms`.
+- `mode="remote"` writes no local file and takes no lock; chain continuity there
+  is ImmutableLog's job.
+
+### Durability (`fsync`)
+
+By default `log()` returns once the event is handed to the operating system,
+which survives the **process** crashing but not the **machine** losing power. For
+a hard guarantee, pass `fsync=True`:
+
+```python
+audit = AuditLogger(app_name="billing-api", fsync=True)
+```
+
+Every append then waits for the disk. It is expensive — about 3 ms per event on
+macOS (which uses `F_FULLFSYNC`) and typically 0.1–2 ms on Linux SSDs, versus
+~30 µs without it — so it is opt-in.
+
 ---
 
 ## FastAPI
@@ -339,7 +387,7 @@ audit.verify()         # still valid, even after flush_pending()
 
 ## API Reference
 
-### `AuditLogger(app_name, file_path="./audit.jsonl", mode=None, immutablelog_url=None, immutablelog_api_key=None, timeout_ms=500, retry_enabled=True, max_retries=3, immutablelog_env=None)`
+### `AuditLogger(app_name, file_path="./audit.jsonl", mode=None, immutablelog_url=None, immutablelog_api_key=None, timeout_ms=500, retry_enabled=True, max_retries=3, immutablelog_env=None, fsync=False)`
 
 | Parameter | Type | Description |
 |---|---|---|
@@ -352,6 +400,7 @@ audit.verify()         # still valid, even after flush_pending()
 | `retry_enabled` | `bool` | If `True`, retries retryable errors (5xx, timeout) up to `max_retries` times |
 | `max_retries` | `int` | Maximum number of retries (in addition to the initial attempt) |
 | `immutablelog_env` | `str \| None` | Logical environment (`meta.env`, e.g. `"production"`). `None` falls back to `IMMUTABLELOG_ENV`; if neither is set, the field is omitted |
+| `fsync` | `bool` | If `True`, every local append is flushed to disk before `log()` returns. See [Durability](#durability-fsync) |
 
 See [ImmutableLog Integration](#immutablelog-integration) for details on each mode.
 

{rust_py_audit-0.3.3 → rust_py_audit-0.4.2}/README.md

@@ -18,7 +18,8 @@ Records audit events (`who did what, when, on which resource`) in a fast, struct
 - **`AuditLogger`** — simple API: `log(...)`, `verify()`, `last_hash()`
 - **Hash chain (SHA-256)** — each event embeds the hash of the previous event; altering any recorded event breaks the chain in a detectable way
 - **JSONL storage** — one event per line, append-only, no database required
-- **Thread-safe** — a single `AuditLogger` can be shared across threads (e.g. a multi-threaded WSGI server, or one middleware instance serving concurrent requests); the hash chain stays linear under concurrency
+- **Thread-safe and multi-process-safe** — share one `AuditLogger` across threads, or point several worker processes (gunicorn, `uvicorn --workers`) at the same file: a cross-process file lock keeps the hash chain linear (see [Multiple workers](#multiple-workers))
+- **Optional `fsync`** — `fsync=True` makes `log()` return only once the event is on disk, surviving a power loss
 - **Free-form `metadata`** — any JSON-serializable `dict` (IP, reason, request_id, etc.)
 - **FastAPI middleware** — automatically logs state-changing requests (POST/PUT/PATCH/DELETE)
 - **Django middleware** — same idea, supports WSGI and ASGI
@@ -107,6 +108,53 @@ If any event was edited, removed, or reordered:
 # or "reason": "broken_chain" (removed/reordered/forged event)
 ```
 
+### Multiple workers
+
+Several processes can write to the same `file_path` — the usual gunicorn /
+`uvicorn --workers N` setup with one `AuditLogger` (or middleware) per worker:
+
+```python
+# every worker
+audit = AuditLogger(app_name="billing-api", file_path="/var/log/billing/audit.jsonl")
+```
+
+Each append takes an exclusive file lock on `<file_path>.lock` (created next to
+the log; `flock` on Unix, `LockFileEx` on Windows). Holding it, the logger checks
+whether the file grew since its own last write — meaning another worker wrote —
+and, if so, re-reads the last hash from the **tail** of the file before chaining.
+A single process never pays for that re-read, and the lock costs microseconds.
+
+Before 0.4.0 each process chained onto the last hash it kept in memory, so two
+workers produced events with the same `previous_hash` and `verify()` reported
+`broken_chain` on a file nobody had tampered with. If you ran several workers on
+an older version, `verify()` on that file will fail at the first point where two
+workers interleaved; start a new file after upgrading.
+
+Notes:
+
+- The lock is advisory and needs a filesystem with working locks — a local disk,
+  not most NFS/SMB mounts.
+- In `mode="hybrid"` the network delivery happens inside the lock (the event's
+  hash, sent to ImmutableLog, depends on the previous one), so concurrent
+  `log()` calls across workers serialize on delivery time too — bounded by
+  `timeout_ms`.
+- `mode="remote"` writes no local file and takes no lock; chain continuity there
+  is ImmutableLog's job.
+
+### Durability (`fsync`)
+
+By default `log()` returns once the event is handed to the operating system,
+which survives the **process** crashing but not the **machine** losing power. For
+a hard guarantee, pass `fsync=True`:
+
+```python
+audit = AuditLogger(app_name="billing-api", fsync=True)
+```
+
+Every append then waits for the disk. It is expensive — about 3 ms per event on
+macOS (which uses `F_FULLFSYNC`) and typically 0.1–2 ms on Linux SSDs, versus
+~30 µs without it — so it is opt-in.
+
 ---
 
 ## FastAPI
@@ -303,7 +351,7 @@ audit.verify()         # still valid, even after flush_pending()
 
 ## API Reference
 
-### `AuditLogger(app_name, file_path="./audit.jsonl", mode=None, immutablelog_url=None, immutablelog_api_key=None, timeout_ms=500, retry_enabled=True, max_retries=3, immutablelog_env=None)`
+### `AuditLogger(app_name, file_path="./audit.jsonl", mode=None, immutablelog_url=None, immutablelog_api_key=None, timeout_ms=500, retry_enabled=True, max_retries=3, immutablelog_env=None, fsync=False)`
 
 | Parameter | Type | Description |
 |---|---|---|
@@ -316,6 +364,7 @@ audit.verify()         # still valid, even after flush_pending()
 | `retry_enabled` | `bool` | If `True`, retries retryable errors (5xx, timeout) up to `max_retries` times |
 | `max_retries` | `int` | Maximum number of retries (in addition to the initial attempt) |
 | `immutablelog_env` | `str \| None` | Logical environment (`meta.env`, e.g. `"production"`). `None` falls back to `IMMUTABLELOG_ENV`; if neither is set, the field is omitted |
+| `fsync` | `bool` | If `True`, every local append is flushed to disk before `log()` returns. See [Durability](#durability-fsync) |
 
 See [ImmutableLog Integration](#immutablelog-integration) for details on each mode.
 

{rust_py_audit-0.3.3 → rust_py_audit-0.4.2}/ROADMAP.md

@@ -34,6 +34,15 @@ what is done and the **directional** ideas under consideration.
 
 ---
 
+## Shipped in 0.4.0
+
+- ✅ **Multi-process safety** — a cross-process file lock (`<file_path>.lock`)
+  serializes appends; a logger re-reads the last hash from the file tail when
+  another process wrote since its last append. Several gunicorn/uvicorn workers
+  can share one JSONL and `verify()` stays valid.
+- ✅ **Optional `fsync`** (`AuditLogger(..., fsync=True)`), and the atomic
+  rewrite used by `flush_pending()` now syncs before its `rename`.
+
 ## Directional ideas (no version assigned — confirm before planning)
 
 - 💡 **Log rotation / segmentation** — roll the JSONL by size or date while
@@ -53,6 +62,10 @@ what is done and the **directional** ideas under consideration.
 ## Known limitations (by design, for now)
 
 - Local JSONL is single-file and append-only (no built-in rotation yet).
+- The cross-process lock needs a filesystem with working advisory locks (local
+  disk; most NFS/SMB mounts don't qualify).
+- In `mode="hybrid"`, delivery runs inside the cross-process lock, so workers
+  serialize on network time (bounded by `timeout_ms`).
 - `verify()` re-reads the entire file (O(n)); fine for typical logs, see the
   incremental-verification idea above for very large files.
 - ImmutableLog delivery is synchronous on the `log()` path (bounded by

{rust_py_audit-0.3.3 → rust_py_audit-0.4.2}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "maturin"
 
 [project]
 name = "rust-py-audit"
-version = "0.3.3"
+version = "0.4.2"
 description = "Fast, tamper-evident event auditing (hash chain) for Python apps, with a Rust core."
 readme = "README.md"
 # Forma do PEP 639: expressão SPDX + arquivos de licença declarados. O

{rust_py_audit-0.3.3 → rust_py_audit-0.4.2}/python/rust_py_audit/__init__.py

@@ -8,5 +8,5 @@ que existe um módulo nativo por trás.
 
 from ._rust_py_audit import AuditLogger, hello
 
-__version__ = "0.3.3"
+__version__ = "0.4.2"
 __all__ = ["AuditLogger", "hello"]

{rust_py_audit-0.3.3 → rust_py_audit-0.4.2}/src/audit_logger.rs

@@ -71,14 +71,19 @@ use crate::verifier::verify_chain;
 /// segura o lock. Por isso `log()`/`flush_pending()`/`last_hash()`
 /// envolvem o uso do lock em `allow_threads`.
 ///
-/// Limitação consciente do MVP: esse cache assume que só **este**
-/// `AuditLogger` (este processo) escreve no arquivo. Se dois processos
-/// diferentes apontarem para o mesmo `file_path` e chamarem `log()`
-/// concorrentemente, o cache de um processo pode ficar desatualizado em
-/// relação ao que o outro gravou — a cadeia no arquivo continuaria
-/// íntegra (cada processo encadeia com o que *ele* sabia ser o último
-/// hash), mas teríamos duas pontas de cadeia em paralelo. Resolver isso
-/// exigiria lock de arquivo entre processos, fora do escopo do MVP.
+/// Vários processos (desde a 0.4): o `Mutex` só serializa threads do
+/// MESMO processo. Com vários workers (gunicorn, uvicorn --workers)
+/// gravando no mesmo `file_path`, cada um tinha seu próprio `last_hash` em
+/// memória — dois eventos acabavam com o mesmo `previous_hash` e
+/// `verify()` acusava adulteração num arquivo que ninguém adulterou. Agora,
+/// nos modos que gravam local (`local`/`hybrid`), a seção crítica também
+/// segura um lock de arquivo entre processos (`storage::ChainLock`, num
+/// `<file_path>.lock` ao lado) e, já com ele, confere se o arquivo cresceu
+/// desde o nosso último append: se cresceu, outro processo gravou, e o
+/// `last_hash` é relido do fim do arquivo (só a última linha). Se não
+/// cresceu, o cache vale — o caso de um processo só continua O(1).
+///
+/// Ordem dos locks: sempre o `Mutex` primeiro, depois o `ChainLock`.
 ///
 /// Limitação específica de `mode="remote"`: como esse modo NÃO grava
 /// JSONL local, `last_hash` vive apenas em memória. Ao recriar o
@@ -93,7 +98,14 @@ use crate::verifier::verify_chain;
 pub struct AuditLogger {
     app_name: String,
     file_path: PathBuf,
-    last_hash: Mutex<Option<String>>,
+    last_hash: Mutex<ChainHead>,
+    /// `fsync` depois de cada append (padrão `false`). Com `true`, o
+    /// `log()` só volta depois de o evento estar no disco, não só no cache
+    /// do SO — ao custo de ~1–3 ms por evento (`F_FULLFSYNC` no macOS).
+    fsync: bool,
+    /// Handle do `<file_path>.lock`, aberto uma vez. `Some` nos modos que
+    /// gravam local; é o lock entre processos da cadeia.
+    lock_file: Option<std::fs::File>,
     /// Modo de operação (`local`/`remote`/`hybrid`). Por ora só fica
     /// guardado e exposto via getter — `log()` ainda se comporta como
     /// antes (sempre local) independente do valor aqui. O envio remoto
@@ -134,7 +146,9 @@ impl AuditLogger {
         retry_enabled = true,
         max_retries = 3,
         immutablelog_env = None,
+        fsync = false,
     ))]
+    #[allow(clippy::too_many_arguments)]
     fn new(
         app_name: String,
         file_path: String,
@@ -145,6 +159,7 @@ impl AuditLogger {
         retry_enabled: bool,
         max_retries: u8,
         immutablelog_env: Option<String>,
+        fsync: bool,
     ) -> PyResult<Self> {
         let file_path = PathBuf::from(file_path);
 
@@ -176,10 +191,22 @@ impl AuditLogger {
             .last()
             .map(|event| event.hash.clone());
 
+        let file_len = storage::file_len(&file_path)?;
+        let lock_file = if mode.saves_local_jsonl() {
+            Some(storage::open_lock_file(&file_path)?)
+        } else {
+            None
+        };
+
         Ok(AuditLogger {
             app_name,
             file_path,
-            last_hash: Mutex::new(last_hash),
+            last_hash: Mutex::new(ChainHead {
+                hash: last_hash,
+                file_len,
+            }),
+            fsync,
+            lock_file,
             mode,
             immutablelog,
             client,
@@ -226,6 +253,11 @@ impl AuditLogger {
         self.immutablelog.env.clone()
     }
 
+    #[getter]
+    fn fsync(&self) -> bool {
+        self.fsync
+    }
+
     /// Devolve o hash do último evento gravado, ou `None` se o logger
     /// ainda não registrou nenhum evento (nem leu nenhum de um arquivo
     /// existente).
@@ -244,7 +276,7 @@ impl AuditLogger {
     /// O `allow_threads` em volta do lock segue a REGRA CRÍTICA descrita
     /// na doc da struct: nunca travar o `Mutex` segurando o GIL.
     fn last_hash(&self, py: Python<'_>) -> Option<String> {
-        py.allow_threads(|| self.lock_last_hash().clone())
+        py.allow_threads(|| self.lock_last_hash().hash.clone())
     }
 
     /// Registra um novo evento de auditoria.
@@ -406,9 +438,21 @@ impl AuditLogger {
                 // serializando contra um `log()` concorrente. As funções em
                 // lote releem os arquivos aqui dentro, então eventos
                 // acrescentados nesse meio-tempo são preservados.
-                let _guard = self.lock_last_hash();
+                // O `ChainLock` também: outro worker pode estar anexando ao
+                // mesmo arquivo, e a reescrita (ler + trocar por `rename`)
+                // perderia o evento dele.
+                let mut guard = self.lock_last_hash();
+                let _file_lock = self
+                    .lock_file
+                    .as_ref()
+                    .map(storage::ChainLock::acquire)
+                    .transpose()?;
                 storage::update_event_receipts(&self.file_path, &receipts)?;
                 storage::remove_events(&pending_path, &handled)?;
+                // A reescrita muda o tamanho; o hash do fim continua o mesmo
+                // (receipt não entra no hash), mas o próximo `log()` não
+                // precisa reler a cauda por causa de uma mudança nossa.
+                guard.file_len = storage::file_len(&self.file_path)?;
 
                 Ok((flushed, failed, total - flushed - failed))
             },
@@ -423,6 +467,14 @@ impl AuditLogger {
     }
 }
 
+/// Ponta da cadeia como este processo a conhece: o hash do último evento e
+/// o tamanho do arquivo logo depois de gravá-lo. Se o arquivo não tiver mais
+/// esse tamanho, outro processo gravou e `hash` está velho.
+struct ChainHead {
+    hash: Option<String>,
+    file_len: u64,
+}
+
 /// Métodos auxiliares internos — fora do bloco `#[pymethods]` de
 /// propósito: nada aqui deve ser exposto como método Python de
 /// `AuditLogger`.
@@ -436,7 +488,7 @@ impl AuditLogger {
     ///
     /// IMPORTANTE: só chamar com o GIL liberado (ver REGRA CRÍTICA na
     /// doc da struct).
-    fn lock_last_hash(&self) -> std::sync::MutexGuard<'_, Option<String>> {
+    fn lock_last_hash(&self) -> std::sync::MutexGuard<'_, ChainHead> {
         self.last_hash
             .lock()
             .unwrap_or_else(|poisoned| poisoned.into_inner())
@@ -498,6 +550,21 @@ impl AuditLogger {
     ) -> Result<AuditEvent, crate::errors::AuditError> {
         let mut guard = self.lock_last_hash();
 
+        // Modos que gravam local: lock entre processos e, se outro processo
+        // gravou desde o nosso último append (o arquivo mudou de tamanho),
+        // relê o `last_hash` do fim do arquivo antes de encadear.
+        let _file_lock = if let Some(lock_file) = &self.lock_file {
+            let lock = storage::ChainLock::acquire(lock_file)?;
+            let len = storage::file_len(&self.file_path)?;
+            if len != guard.file_len {
+                guard.hash = storage::read_last_hash(&self.file_path)?;
+                guard.file_len = len;
+            }
+            Some(lock)
+        } else {
+            None
+        };
+
         // `hash` começa vazio: só dá para calculá-lo depois que todos os
         // outros campos existem (`compute_hash` ignora o campo `hash`).
         let mut event = AuditEvent {
@@ -509,7 +576,7 @@ impl AuditLogger {
             resource,
             resource_id,
             metadata,
-            previous_hash: guard.clone(),
+            previous_hash: guard.hash.clone(),
             hash: String::new(),
             severity,
             immutable_trail,
@@ -519,8 +586,8 @@ impl AuditLogger {
 
         match self.mode {
             AuditMode::Local => {
-                storage::append_event(&self.file_path, &event)?;
-                *guard = Some(event.hash.clone());
+                guard.file_len = storage::append_event(&self.file_path, &event, self.fsync)?;
+                guard.hash = Some(event.hash.clone());
             }
             AuditMode::Remote => {
                 // Não grava JSONL local: se o envio falhar, o erro sobe
@@ -530,7 +597,7 @@ impl AuditLogger {
                     .deliver(&event, resolved_severity, event.immutable_trail.as_deref())
                     .map_err(crate::errors::AuditError::from)?;
                 event.immutablelog = Some(receipt);
-                *guard = Some(event.hash.clone());
+                guard.hash = Some(event.hash.clone());
             }
             AuditMode::Hybrid => {
                 // Entrega ANTES de gravar, para anexar o evento ao JSONL
@@ -571,10 +638,14 @@ impl AuditLogger {
                 // a ficar gravado como `pending` no arquivo principal sem
                 // estar na fila (preso sem reenvio).
                 if queue_for_retry {
-                    storage::append_event(&storage::pending_path_for(&self.file_path), &event)?;
+                    storage::append_event(
+                        &storage::pending_path_for(&self.file_path),
+                        &event,
+                        self.fsync,
+                    )?;
                 }
-                storage::append_event(&self.file_path, &event)?;
-                *guard = Some(event.hash.clone());
+                guard.file_len = storage::append_event(&self.file_path, &event, self.fsync)?;
+                guard.hash = Some(event.hash.clone());
             }
         }
 

{rust_py_audit-0.3.3 → rust_py_audit-0.4.2}/src/storage.rs

@@ -1,7 +1,9 @@
 use std::fs::{File, OpenOptions};
-use std::io::{BufRead, BufReader, Write};
+use std::io::{BufRead, BufReader, Read, Seek, SeekFrom, Write};
 use std::path::{Path, PathBuf};
 
+use fs2::FileExt;
+
 use crate::errors::AuditError;
 use crate::event::AuditEvent;
 use crate::immutablelog_receipt::ImmutableLogReceipt;
@@ -26,6 +28,133 @@ pub fn pending_path_for(path: &Path) -> PathBuf {
     }
 }
 
+/// Caminho do arquivo de lock que serializa a cadeia entre processos:
+/// `"./audit.jsonl"` -> `"./audit.jsonl.lock"`.
+///
+/// O lock fica num arquivo À PARTE, e não no próprio JSONL, porque
+/// `rewrite_events` troca o JSONL por `rename` — um lock preso ao inode
+/// antigo deixaria de proteger o arquivo novo sem ninguém perceber.
+pub fn lock_path_for(path: &Path) -> PathBuf {
+    let mut name = path
+        .file_name()
+        .map(|name| name.to_os_string())
+        .unwrap_or_else(|| "audit.jsonl".into());
+    name.push(".lock");
+    path.with_file_name(name)
+}
+
+/// Lock exclusivo entre processos sobre a cadeia de um `file_path`.
+/// Liberado no `Drop` (e pelo SO, se o processo morrer segurando-o — não
+/// há lock órfão a limpar à mão).
+///
+/// É isto que mantém a cadeia linear com vários workers: sem o lock, cada
+/// processo encadeava no `last_hash` que *ele* tinha em memória, dois
+/// eventos acabavam com o mesmo `previous_hash` e `verify()` acusava
+/// adulteração num arquivo que ninguém adulterou.
+///
+/// O lock vale por *descrição de arquivo aberta*: threads do mesmo processo
+/// compartilhando o handle não se excluem por ele — quem as serializa é o
+/// `Mutex` do logger, sempre travado antes.
+pub struct ChainLock<'a> {
+    file: &'a File,
+}
+
+impl<'a> ChainLock<'a> {
+    /// Bloqueia até obter o lock exclusivo sobre `lock_file` (aberto com
+    /// [`open_lock_file`]).
+    pub fn acquire(lock_file: &'a File) -> Result<Self, AuditError> {
+        lock_file
+            .lock_exclusive()
+            .map_err(|err| AuditError::Io(format!("lock da cadeia: {err}")))?;
+        Ok(ChainLock { file: lock_file })
+    }
+}
+
+impl Drop for ChainLock<'_> {
+    fn drop(&mut self) {
+        let _ = FileExt::unlock(self.file);
+    }
+}
+
+/// Abre (criando se preciso) o `.lock` de `path`. O logger abre uma vez e
+/// guarda o handle: diferente do JSONL, o `.lock` nunca é trocado por
+/// `rename`, então o handle continua válido — e o `log()` economiza um
+/// `open` por evento.
+pub fn open_lock_file(path: &Path) -> Result<File, AuditError> {
+    let lock_path = lock_path_for(path);
+    if let Some(parent) = lock_path.parent() {
+        if !parent.as_os_str().is_empty() {
+            std::fs::create_dir_all(parent).map_err(|err| AuditError::Io(err.to_string()))?;
+        }
+    }
+    OpenOptions::new()
+        .create(true)
+        .truncate(false)
+        .write(true)
+        .open(&lock_path)
+        .map_err(|err| AuditError::Io(format!("{lock_path:?}: {err}")))
+}
+
+/// Tamanho do arquivo em bytes; `0` se ele ainda não existe.
+pub fn file_len(path: &Path) -> Result<u64, AuditError> {
+    match std::fs::metadata(path) {
+        Ok(meta) => Ok(meta.len()),
+        Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(0),
+        Err(err) => Err(AuditError::Io(err.to_string())),
+    }
+}
+
+/// Hash do último evento do arquivo, lendo **só o fim** dele.
+///
+/// Usado quando outro processo gravou desde o nosso último `log()`: em
+/// vez de reler o arquivo inteiro (O(n)), lemos blocos de trás para a
+/// frente até achar a última linha não vazia. Custa O(tamanho da última
+/// linha).
+pub fn read_last_hash(path: &Path) -> Result<Option<String>, AuditError> {
+    const CHUNK: u64 = 8 * 1024;
+
+    let mut file = match File::open(path) {
+        Ok(file) => file,
+        Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(None),
+        Err(err) => return Err(AuditError::Io(err.to_string())),
+    };
+    let io = |err: std::io::Error| AuditError::Io(err.to_string());
+
+    let mut pos = file.seek(SeekFrom::End(0)).map_err(io)?;
+    let mut tail: Vec<u8> = Vec::new();
+    loop {
+        // Fim útil = depois de descartar quebras de linha/espaços finais.
+        let end = tail
+            .iter()
+            .rposition(|b| !b.is_ascii_whitespace())
+            .map(|i| i + 1);
+        if let Some(end) = end {
+            if let Some(start) = tail[..end].iter().rposition(|&b| b == b'\n') {
+                return parse_hash(&tail[start + 1..end]).map(Some);
+            }
+            if pos == 0 {
+                return parse_hash(&tail[..end]).map(Some);
+            }
+        } else if pos == 0 {
+            return Ok(None); // arquivo vazio ou só com espaços
+        }
+
+        let step = CHUNK.min(pos);
+        pos -= step;
+        file.seek(SeekFrom::Start(pos)).map_err(io)?;
+        let mut chunk = vec![0u8; step as usize];
+        file.read_exact(&mut chunk).map_err(io)?;
+        chunk.extend_from_slice(&tail);
+        tail = chunk;
+    }
+}
+
+fn parse_hash(line: &[u8]) -> Result<String, AuditError> {
+    let event: AuditEvent = serde_json::from_slice(line)
+        .map_err(|err| AuditError::Serialization(format!("última linha: {err}")))?;
+    Ok(event.hash)
+}
+
 /// Acrescenta um evento ao final do arquivo JSONL, criando o arquivo
 /// (e os diretórios pais, se preciso) caso ainda não existam.
 ///
@@ -39,7 +168,12 @@ pub fn pending_path_for(path: &Path) -> PathBuf {
 /// Recebe `path: &Path` (uma referência emprestada) — esta função não
 /// precisa ser dona do caminho, só precisa lê-lo para abrir o arquivo.
 /// Quem chama (o `AuditLogger`, na Etapa 7) continua dono do `PathBuf`.
-pub fn append_event(path: &Path, event: &AuditEvent) -> Result<(), AuditError> {
+///
+/// Com `sync = true`, chama `sync_data()` (fsync) antes de devolver: o
+/// evento está no disco, não só no cache do SO, e sobrevive a uma queda de
+/// energia. Devolve o tamanho do arquivo depois da escrita, que o logger
+/// usa para notar se outro processo gravou desde então.
+pub fn append_event(path: &Path, event: &AuditEvent, sync: bool) -> Result<u64, AuditError> {
     if let Some(parent) = path.parent() {
         if !parent.as_os_str().is_empty() {
             std::fs::create_dir_all(parent).map_err(|err| AuditError::Io(err.to_string()))?;
@@ -67,8 +201,14 @@ pub fn append_event(path: &Path, event: &AuditEvent) -> Result<(), AuditError> {
     // processo Python morrer logo após o `log()` retornar.
     file.flush()
         .map_err(|err| AuditError::Io(err.to_string()))?;
+    if sync {
+        file.sync_data()
+            .map_err(|err| AuditError::Io(err.to_string()))?;
+    }
 
-    Ok(())
+    file.metadata()
+        .map(|meta| meta.len())
+        .map_err(|err| AuditError::Io(err.to_string()))
 }
 
 /// Lê todos os eventos do arquivo JSONL, em ordem (do mais antigo para
@@ -139,6 +279,11 @@ fn rewrite_events(path: &Path, events: &[AuditEvent]) -> Result<(), AuditError>
     tmp_file
         .flush()
         .map_err(|err| AuditError::Io(err.to_string()))?;
+    // No disco antes do `rename`: senão uma queda de energia logo após a
+    // troca pode deixar o arquivo final vazio ou truncado.
+    tmp_file
+        .sync_data()
+        .map_err(|err| AuditError::Io(err.to_string()))?;
     drop(tmp_file);
 
     std::fs::rename(&tmp_path, path).map_err(|err| AuditError::Io(err.to_string()))?;
@@ -231,6 +376,78 @@ mod tests {
     use serde_json::json;
     use std::path::PathBuf;
 
+    #[test]
+    fn read_last_hash_reads_only_the_tail() {
+        let path = temp_path();
+        assert_eq!(read_last_hash(&path).unwrap(), None);
+
+        // Muitos eventos com metadata grande: o arquivo passa de vários
+        // blocos de 8 KiB, e a última linha cruza a fronteira de um bloco.
+        let mut last = String::new();
+        for i in 0..50 {
+            let mut event = sample_event("LOGIN", None);
+            event.metadata = json!({ "pad": "x".repeat(3_000 + i) });
+            event.hash = format!("hash-{i}");
+            append_event(&path, &event, false).unwrap();
+            last = event.hash.clone();
+        }
+        assert_eq!(read_last_hash(&path).unwrap(), Some(last));
+
+        // Quebras de linha extras no fim não confundem a leitura.
+        std::fs::OpenOptions::new()
+            .append(true)
+            .open(&path)
+            .unwrap()
+            .write_all(b"\n\n")
+            .unwrap();
+        assert_eq!(read_last_hash(&path).unwrap().as_deref(), Some("hash-49"));
+        let _ = std::fs::remove_file(&path);
+    }
+
+    #[test]
+    fn append_returns_the_new_length() {
+        let path = temp_path();
+        let len = append_event(&path, &sample_event("LOGIN", None), true).unwrap();
+        assert_eq!(len, file_len(&path).unwrap());
+        assert!(len > 0);
+        let _ = std::fs::remove_file(&path);
+    }
+
+    #[test]
+    fn chain_lock_is_exclusive_across_handles() {
+        // Dois `ChainLock` no mesmo processo usam descritores diferentes,
+        // o que exercita o mesmo caminho do flock entre processos.
+        let path = temp_path();
+        let first_file = open_lock_file(&path).unwrap();
+        let first = ChainLock::acquire(&first_file).unwrap();
+
+        let (tx, rx) = std::sync::mpsc::channel();
+        let path2 = path.clone();
+        let waiter = std::thread::spawn(move || {
+            let second_file = open_lock_file(&path2).unwrap();
+            let _second = ChainLock::acquire(&second_file).unwrap();
+            tx.send(()).unwrap();
+        });
+        assert!(
+            rx.recv_timeout(std::time::Duration::from_millis(200))
+                .is_err(),
+            "o segundo lock não podia ser obtido com o primeiro ativo"
+        );
+        drop(first);
+        rx.recv_timeout(std::time::Duration::from_secs(5))
+            .expect("o segundo lock deveria sair assim que o primeiro caísse");
+        waiter.join().unwrap();
+        let _ = std::fs::remove_file(lock_path_for(&path));
+    }
+
+    #[test]
+    fn lock_path_sits_next_to_the_log() {
+        assert_eq!(
+            lock_path_for(Path::new("/var/log/app/audit.jsonl")),
+            PathBuf::from("/var/log/app/audit.jsonl.lock")
+        );
+    }
+
     fn temp_path() -> PathBuf {
         // Usa uuid (já é dependência do projeto) para gerar um nome de
         // arquivo único por teste, evitando que testes rodando em
@@ -270,7 +487,7 @@ mod tests {
         let path = temp_path();
         let event = sample_event("LOGIN", None);
 
-        append_event(&path, &event).expect("append não deveria falhar");
+        append_event(&path, &event, false).expect("append não deveria falhar");
         let events = read_events(&path).expect("read não deveria falhar");
 
         assert_eq!(events, vec![event]);
@@ -284,8 +501,8 @@ mod tests {
         let first = sample_event("LOGIN", None);
         let second = sample_event("DELETE_INVOICE", Some("hash-of-first"));
 
-        append_event(&path, &first).expect("append não deveria falhar");
-        append_event(&path, &second).expect("append não deveria falhar");
+        append_event(&path, &first, false).expect("append não deveria falhar");
+        append_event(&path, &second, false).expect("append não deveria falhar");
         let events = read_events(&path).expect("read não deveria falhar");
 
         assert_eq!(events, vec![first, second]);
@@ -325,8 +542,8 @@ mod tests {
         let path = temp_path();
         let first = sample_event("LOGIN", None);
         let second = sample_event("LOGOUT", Some(&first.hash));
-        append_event(&path, &first).expect("append não deveria falhar");
-        append_event(&path, &second).expect("append não deveria falhar");
+        append_event(&path, &first, false).expect("append não deveria falhar");
+        append_event(&path, &second, false).expect("append não deveria falhar");
 
         let receipt = crate::immutablelog_receipt::ImmutableLogReceipt {
             status: "delivered".to_string(),
@@ -351,7 +568,8 @@ mod tests {
     #[test]
     fn update_event_receipt_fails_for_unknown_event_id() {
         let path = temp_path();
-        append_event(&path, &sample_event("LOGIN", None)).expect("append não deveria falhar");
+        append_event(&path, &sample_event("LOGIN", None), false)
+            .expect("append não deveria falhar");
 
         let receipt = crate::immutablelog_receipt::ImmutableLogReceipt::pending();
         let result = update_event_receipt(&path, "evento-inexistente", &receipt);
@@ -367,9 +585,9 @@ mod tests {
         let first = sample_event("LOGIN", None);
         let second = sample_event("LOGOUT", Some(&first.hash));
         let third = sample_event("DELETE", Some(&second.hash));
-        append_event(&path, &first).expect("append não deveria falhar");
-        append_event(&path, &second).expect("append não deveria falhar");
-        append_event(&path, &third).expect("append não deveria falhar");
+        append_event(&path, &first, false).expect("append não deveria falhar");
+        append_event(&path, &second, false).expect("append não deveria falhar");
+        append_event(&path, &third, false).expect("append não deveria falhar");
 
         let mut receipts = std::collections::HashMap::new();
         receipts.insert(first.id.clone(), ImmutableLogReceipt::pending());
@@ -408,9 +626,9 @@ mod tests {
         let first = sample_event("LOGIN", None);
         let second = sample_event("LOGOUT", Some(&first.hash));
         let third = sample_event("DELETE", Some(&second.hash));
-        append_event(&path, &first).expect("append não deveria falhar");
-        append_event(&path, &second).expect("append não deveria falhar");
-        append_event(&path, &third).expect("append não deveria falhar");
+        append_event(&path, &first, false).expect("append não deveria falhar");
+        append_event(&path, &second, false).expect("append não deveria falhar");
+        append_event(&path, &third, false).expect("append não deveria falhar");
 
         let mut ids = std::collections::HashSet::new();
         ids.insert(first.id.clone());
@@ -426,7 +644,8 @@ mod tests {
     #[test]
     fn batch_helpers_are_noops_when_empty() {
         let path = temp_path();
-        append_event(&path, &sample_event("LOGIN", None)).expect("append não deveria falhar");
+        append_event(&path, &sample_event("LOGIN", None), false)
+            .expect("append não deveria falhar");
 
         update_event_receipts(&path, &std::collections::HashMap::new()).expect("noop");
         remove_events(&path, &std::collections::HashSet::new()).expect("noop");
@@ -442,8 +661,8 @@ mod tests {
         let path = temp_path();
         let first = sample_event("LOGIN", None);
         let second = sample_event("LOGOUT", Some(&first.hash));
-        append_event(&path, &first).expect("append não deveria falhar");
-        append_event(&path, &second).expect("append não deveria falhar");
+        append_event(&path, &first, false).expect("append não deveria falhar");
+        append_event(&path, &second, false).expect("append não deveria falhar");
 
         remove_event(&path, &first.id).expect("remove não deveria falhar");
 

rust_py_audit-0.4.2/tests/test_multiprocess.py

@@ -0,0 +1,80 @@
+"""Vários processos gravando no mesmo JSONL (gunicorn com N workers).
+
+Antes da 0.4, cada processo encadeava no `last_hash` que tinha em memória:
+dois eventos saíam com o mesmo `previous_hash` e `verify()` acusava
+adulteração num arquivo que ninguém tinha adulterado. O lock de arquivo entre
+processos mantém a cadeia linear.
+"""
+
+import multiprocessing
+import os
+
+from rust_py_audit import AuditLogger
+
+WORKERS = 4
+EVENTS_PER_WORKER = 50
+
+
+def _worker(path, worker_id, ready, go):
+    audit = AuditLogger("app", path)
+    ready.wait()  # todos abriram o logger antes de qualquer um gravar
+    go.wait()
+    for i in range(EVENTS_PER_WORKER):
+        audit.log(f"worker-{worker_id}", "TICK", "job", str(i))
+
+
+def _run_workers(path):
+    ctx = multiprocessing.get_context("spawn")
+    ready = ctx.Barrier(WORKERS)
+    go = ctx.Barrier(WORKERS)
+    procs = [ctx.Process(target=_worker, args=(path, w, ready, go)) for w in range(WORKERS)]
+    for p in procs:
+        p.start()
+    for p in procs:
+        p.join(timeout=60)
+        assert p.exitcode == 0
+
+
+def test_concurrent_processes_keep_a_single_valid_chain(tmp_path):
+    path = str(tmp_path / "audit.jsonl")
+    _run_workers(path)
+
+    result = AuditLogger("app", path).verify()
+    assert result["valid"] is True, result
+    assert result["total_events"] == WORKERS * EVENTS_PER_WORKER
+
+
+def test_logger_picks_up_events_written_by_another_process(tmp_path):
+    path = str(tmp_path / "audit.jsonl")
+    mine = AuditLogger("app", path)
+    mine.log("me", "FIRST", "doc", "1")
+
+    # Outro processo grava depois que `mine` já cacheou o último hash.
+    ctx = multiprocessing.get_context("spawn")
+    ready, go = ctx.Barrier(1), ctx.Barrier(1)
+    other = ctx.Process(target=_worker, args=(path, 9, ready, go))
+    other.start()
+    other.join(timeout=60)
+    assert other.exitcode == 0
+
+    event = mine.log("me", "AFTER", "doc", "2")
+    result = mine.verify()
+    assert result["valid"] is True, result
+    assert result["total_events"] == 2 + EVENTS_PER_WORKER
+    # Encadeou no último evento do OUTRO processo, não no próprio cache.
+    assert event["previous_hash"] is not None
+    assert mine.last_hash() == event["hash"]
+
+
+def test_lock_file_sits_next_to_the_log(tmp_path):
+    path = tmp_path / "audit.jsonl"
+    AuditLogger("app", str(path)).log("a", "B", "c", "d")
+    assert os.path.exists(str(path) + ".lock")
+
+
+def test_fsync_is_opt_in(tmp_path):
+    assert AuditLogger("app", str(tmp_path / "a.jsonl")).fsync is False
+    durable = AuditLogger("app", str(tmp_path / "b.jsonl"), fsync=True)
+    assert durable.fsync is True
+    durable.log("a", "B", "c", "d")
+    assert durable.verify()["valid"] is True