rust-py-audit 0.2.2__tar.gz → 0.2.3__tar.gz

{rust_py_audit-0.2.2 → rust_py_audit-0.2.3}/Cargo.lock

@@ -1597,7 +1597,7 @@ dependencies = [
 
 [[package]]
 name = "rust_py_audit"
-version = "0.2.2"
+version = "0.2.3"
 dependencies = [
  "httpmock",
  "pyo3",

{rust_py_audit-0.2.2 → rust_py_audit-0.2.3}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rust_py_audit"
-version = "0.2.2"
+version = "0.2.3"
 edition = "2021"
 description = "Auditoria de eventos com cadeia de hashes (SHA-256) para apps Python, core em Rust via PyO3."
 license = "MIT"

{rust_py_audit-0.2.2 → rust_py_audit-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rust-py-audit
-Version: 0.2.2
+Version: 0.2.3
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{rust_py_audit-0.2.2 → rust_py_audit-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "rust-py-audit"
-version = "0.2.2"
+version = "0.2.3"
 description = "Fast, tamper-evident event auditing (hash chain) for Python apps, with a Rust core."
 readme = "README.md"
 license = "MIT"

{rust_py_audit-0.2.2 → rust_py_audit-0.2.3}/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.2.2"
+__version__ = "0.2.3"
 __all__ = ["AuditLogger", "hello"]

{rust_py_audit-0.2.2 → rust_py_audit-0.2.3}/src/audit_logger.rs

@@ -1,4 +1,6 @@
+use std::collections::{HashMap, HashSet};
 use std::path::PathBuf;
+use std::sync::Mutex;
 
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
@@ -34,6 +36,27 @@ use crate::verifier::verify_chain;
 /// `AuditLogger` (`new()`), e depois mantemos o cache atualizado a cada
 /// `log()` bem-sucedido.
 ///
+/// O `Mutex` em volta de `last_hash` serve a dois propósitos ligados a
+/// concorrência:
+/// 1. Permite que `log()` e `flush_pending()` recebam `&self` (em vez de
+///    `&mut self`). Com `&mut self`, o PyO3 mantém um *borrow* mutável
+///    exclusivo durante TODO o método — e como `log()` libera o GIL
+///    durante a chamada de rede (`allow_threads`), uma segunda thread
+///    (ex.: WSGI multi-thread compartilhando o mesmo logger) que
+///    chamasse `log()` ao mesmo tempo receberia `RuntimeError: Already
+///    borrowed`, perdendo o evento. Com `&self` + `Mutex`, isso não
+///    acontece.
+/// 2. Garante que a leitura do `last_hash`, o cálculo do `previous_hash`
+///    e a atualização do cache aconteçam atomicamente — duas threads
+///    nunca encadeiam dois eventos no MESMO `previous_hash` (o que
+///    bifurcaria a cadeia).
+///
+/// REGRA CRÍTICA: este `Mutex` só pode ser travado com o GIL JÁ LIBERADO
+/// (dentro de `py.allow_threads`). Travar segurando o GIL poderia
+/// causar deadlock com a thread que liberou o GIL durante a rede e ainda
+/// 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()`
@@ -42,11 +65,21 @@ use crate::verifier::verify_chain;
 /// í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.
+///
+/// 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
+/// `AuditLogger` (reinício do processo), `new()` relê `file_path` —
+/// que está vazio em remote puro — e `last_hash` volta a `None`, ou
+/// seja, o `previous_hash` REINICIA a cada restart. A continuidade da
+/// cadeia entre reinícios, nesse modo, depende inteiramente do
+/// ImmutableLog do lado servidor, não do encadeamento local. Quem
+/// precisa de cadeia local contínua entre reinícios deve usar
+/// `mode="hybrid"`.
 #[pyclass]
 pub struct AuditLogger {
     app_name: String,
     file_path: PathBuf,
-    last_hash: Option<String>,
+    last_hash: Mutex<Option<String>>,
     /// 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
@@ -132,7 +165,7 @@ impl AuditLogger {
         Ok(AuditLogger {
             app_name,
             file_path,
-            last_hash,
+            last_hash: Mutex::new(last_hash),
             mode,
             immutablelog,
             client,
@@ -193,8 +226,11 @@ impl AuditLogger {
     /// Implementação O(1): só devolve o cache em memória (`Option`
     /// clonado), sem tocar no arquivo em disco — diferente de
     /// `verify()`, que releria tudo de propósito.
-    fn last_hash(&self) -> Option<String> {
-        self.last_hash.clone()
+    ///
+    /// 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())
     }
 
     /// Registra um novo evento de auditoria.
@@ -216,7 +252,7 @@ impl AuditLogger {
     /// depois disso.
     #[pyo3(signature = (actor_id, action, resource, resource_id, metadata = None, severity = None, immutable_trail = None))]
     fn log(
-        &mut self,
+        &self,
         py: Python<'_>,
         actor_id: String,
         action: String,
@@ -226,107 +262,46 @@ impl AuditLogger {
         severity: Option<String>,
         immutable_trail: Option<String>,
     ) -> PyResult<PyObject> {
+        // A conversão de `metadata` (e a validação de `severity`) precisa
+        // do GIL e é feita ANTES de liberar threads: `python_to_json`
+        // inspeciona objetos Python, e validar cedo faz `log()` falhar
+        // rápido mesmo em `mode="local"`.
         let metadata_value = match metadata {
             Some(value) => python_to_json(&value)?,
             None => serde_json::Value::Object(serde_json::Map::new()),
         };
 
-        // Valida `severity` já aqui (falha rápido), mesmo em
-        // `mode="local"` — se alguém passa um valor, ele precisa ser
-        // válido independente do modo. `resolved_severity` é o valor
-        // efetivo usado na PRIMEIRA tentativa de envio (default "info"
-        // quando `severity` é `None`); `event.severity` guarda só o que
-        // foi passado (ou `None`), para `flush_pending()` reenviar mais
-        // tarde com a mesma classificação original.
+        // `resolved_severity` é o valor efetivo usado na PRIMEIRA
+        // tentativa de envio (default "info" quando `severity` é `None`);
+        // `event.severity` guarda só o que foi passado (ou `None`), para
+        // `flush_pending()` reenviar mais tarde com a mesma classificação.
         let resolved_severity =
             resolve_severity(severity.as_deref()).map_err(crate::errors::AuditError::Config)?;
         let sanitized_trail = sanitize_trail(immutable_trail.as_deref());
 
         // RFC3339 em UTC produz exatamente o formato do exemplo do MVP:
-        // "2026-06-17T10:00:00Z". `map_err` converte o erro de
-        // formatação (praticamente impossível de ocorrer aqui, mas
-        // ainda é um `Result`) em `PyErr`, evitando `.unwrap()`.
+        // "2026-06-17T10:00:00Z".
         let timestamp = OffsetDateTime::now_utc()
             .format(&Rfc3339)
             .map_err(|err| pyo3::exceptions::PyValueError::new_err(err.to_string()))?;
 
-        // Montamos o evento com `hash` vazio primeiro: o hash só pode
-        // ser calculado depois que todos os OUTROS campos já existem
-        // (Etapa 5 — `compute_hash` ignora o campo `hash` de propósito,
-        // mas ainda precisamos de algum valor para inicializar o
-        // struct).
-        let mut event = AuditEvent {
-            id: Uuid::new_v4().to_string(),
-            timestamp,
-            app_name: self.app_name.clone(),
-            actor_id,
-            action,
-            resource,
-            resource_id,
-            metadata: metadata_value,
-            previous_hash: self.last_hash.clone(),
-            hash: String::new(),
-            // O hash é calculado a partir só dos campos acima (ver
-            // `hash.rs::HashPayload`) e NUNCA depois — o que vier do
-            // ImmutableLog é só metadado operacional, anexado depois,
-            // sem poder alterar essa "impressão digital" do evento.
-            severity,
-            immutable_trail: sanitized_trail,
-            immutablelog: None,
-        };
-
-        event.hash = compute_hash(&event)?;
-
-        match self.mode {
-            AuditMode::Local => {
-                storage::append_event(&self.file_path, &event)?;
-                self.last_hash = Some(event.hash.clone());
-            }
-            AuditMode::Remote => {
-                // Não grava JSONL local neste modo — se o envio falhar,
-                // o erro sobe como exceção Python e `self.last_hash`
-                // continua apontando para o último evento que de fato
-                // foi confirmado pelo ImmutableLog.
-                let receipt = self.send_to_immutablelog(
-                    py,
-                    &event,
-                    resolved_severity,
-                    event.immutable_trail.as_deref(),
-                )?;
-                event.immutablelog = Some(receipt);
-                self.last_hash = Some(event.hash.clone());
-            }
-            AuditMode::Hybrid => {
-                // Salva local PRIMEIRO: mesmo que o processo morra antes
-                // do envio terminar, o evento já está persistido (sem
-                // receipt ainda) — nunca perdemos o registro local por
-                // causa de uma falha de rede.
-                storage::append_event(&self.file_path, &event)?;
-                self.last_hash = Some(event.hash.clone());
-
-                match self.send_to_immutablelog(
-                    py,
-                    &event,
-                    resolved_severity,
-                    event.immutable_trail.as_deref(),
-                ) {
-                    Ok(receipt) => {
-                        event.immutablelog = Some(receipt.clone());
-                        storage::update_event_receipt(&self.file_path, &event.id, &receipt)?;
-                    }
-                    Err(_) => {
-                        // Falha em hybrid NÃO é exceção Python: o evento
-                        // já está seguro localmente, então devolvemos
-                        // status "pending" e deixamos para
-                        // `flush_pending()` tentar de novo depois.
-                        let pending_receipt = ImmutableLogReceipt::pending();
-                        event.immutablelog = Some(pending_receipt.clone());
-                        storage::update_event_receipt(&self.file_path, &event.id, &pending_receipt)?;
-                        storage::append_event(&storage::pending_path_for(&self.file_path), &event)?;
-                    }
-                }
-            }
-        }
+        // Toda a seção crítica (travar `last_hash`, encadear, gravar
+        // local e/ou enviar à rede, atualizar o cache) roda com o GIL
+        // LIBERADO — ver a REGRA CRÍTICA na doc da struct. `append_chained`
+        // é puro Rust, não toca em objetos Python.
+        let event = py.allow_threads(|| {
+            self.append_chained(
+                actor_id,
+                action,
+                resource,
+                resource_id,
+                metadata_value,
+                timestamp,
+                severity,
+                sanitized_trail,
+                resolved_severity,
+            )
+        })?;
 
         event_to_pydict(py, &event)
     }
@@ -375,30 +350,44 @@ impl AuditLogger {
     fn flush_pending(&self, py: Python<'_>) -> PyResult<PyObject> {
         let pending_path = storage::pending_path_for(&self.file_path);
         let pending_events = storage::read_events(&pending_path)?;
-
-        let mut flushed = 0usize;
-        let mut still_pending = 0usize;
-
-        for event in &pending_events {
-            let severity = resolve_severity(event.severity.as_deref()).map_err(crate::errors::AuditError::Config)?;
-            match self.send_to_immutablelog(py, event, severity, event.immutable_trail.as_deref()) {
-                Ok(receipt) => {
-                    storage::update_event_receipt(&self.file_path, &event.id, &receipt)?;
-                    storage::remove_event(&pending_path, &event.id)?;
-                    flushed += 1;
-                }
-                Err(_) => {
-                    // Continua pendente — fica na fila para a próxima
-                    // chamada de `flush_pending()` tentar de novo.
-                    still_pending += 1;
+        let total = pending_events.len();
+
+        // Igual a `log()`: tudo que trava o `Mutex` ou faz rede roda com
+        // o GIL liberado (REGRA CRÍTICA na doc da struct).
+        let (flushed, still_pending) = py.allow_threads(|| -> Result<(usize, usize), crate::errors::AuditError> {
+            // Primeiro a parte cara/lenta (rede), SEM segurar o lock:
+            // acumulamos os receipts entregues e os ids a remover da fila.
+            let mut delivered: HashMap<String, ImmutableLogReceipt> = HashMap::new();
+            let mut flushed_ids: HashSet<String> = HashSet::new();
+
+            for event in &pending_events {
+                let severity = resolve_severity(event.severity.as_deref())
+                    .map_err(crate::errors::AuditError::Config)?;
+                if let Ok(receipt) = self.deliver(event, severity, event.immutable_trail.as_deref())
+                {
+                    delivered.insert(event.id.clone(), receipt);
+                    flushed_ids.insert(event.id.clone());
                 }
+                // Em falha o evento simplesmente continua na fila para a
+                // próxima chamada de `flush_pending()` tentar de novo.
             }
-        }
+
+            // Só agora travamos, para a parte que mexe nos arquivos —
+            // 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();
+            storage::update_event_receipts(&self.file_path, &delivered)?;
+            storage::remove_events(&pending_path, &flushed_ids)?;
+
+            let flushed = flushed_ids.len();
+            Ok((flushed, total - flushed))
+        })?;
 
         let dict = PyDict::new_bound(py);
         dict.set_item("flushed", flushed)?;
         dict.set_item("still_pending", still_pending)?;
-        dict.set_item("total", pending_events.len())?;
+        dict.set_item("total", total)?;
         Ok(dict.into())
     }
 }
@@ -407,30 +396,135 @@ impl AuditLogger {
 /// propósito: nada aqui deve ser exposto como método Python de
 /// `AuditLogger`.
 impl AuditLogger {
-    /// Envia `event` ao ImmutableLog (com retry), liberando o GIL
-    /// durante a chamada HTTP bloqueante — sem isso, qualquer outra
-    /// thread Python (ex.: o event loop do FastAPI rodando o
-    /// middleware noutra thread, ou um servidor WSGI multi-thread)
-    /// ficaria travada pela duração inteira da requisição/retry.
-    fn send_to_immutablelog(
+    /// Trava o `Mutex` de `last_hash`, recuperando-se de um eventual
+    /// *poisoning* (que só ocorreria se uma thread tivesse entrado em
+    /// panic segurando o lock — improvável aqui, já que a seção crítica
+    /// não chama `.unwrap()`/`panic!`). Recuperar em vez de propagar o
+    /// panic evita derrubar o processo Python inteiro por causa de um
+    /// lock envenenado.
+    ///
+    /// 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>> {
+        self.last_hash
+            .lock()
+            .unwrap_or_else(|poisoned| poisoned.into_inner())
+    }
+
+    /// Envia `event` ao ImmutableLog (com retry). Rust puro: NÃO toca no
+    /// GIL nem o libera — quem chama (`append_chained`/`flush_pending`)
+    /// já está dentro de um `allow_threads`, então a chamada HTTP
+    /// bloqueante já roda com o GIL liberado, sem travar outras threads
+    /// Python.
+    fn deliver(
         &self,
-        py: Python<'_>,
         event: &AuditEvent,
         severity: &str,
         immutable_trail: Option<&str>,
-    ) -> PyResult<ImmutableLogReceipt> {
-        let client = self.client.as_ref().ok_or_else(|| {
-            crate::errors::AuditError::Config(format!(
+    ) -> Result<ImmutableLogReceipt, crate::immutablelog_client::ImmutableLogClientError> {
+        use crate::immutablelog_client::ImmutableLogClientError;
+        let client = self.client.as_ref().ok_or_else(|| ImmutableLogClientError::Permanent {
+            status: None,
+            reason: format!(
                 "mode='{}' exige um cliente ImmutableLog inicializado (estado inconsistente)",
                 self.mode.as_str()
-            ))
+            ),
         })?;
-        let retry_enabled = self.immutablelog.retry_enabled;
-        let max_retries = self.immutablelog.max_retries;
 
-        let result = py.allow_threads(|| {
-            send_with_retry(client, event, severity, immutable_trail, retry_enabled, max_retries)
-        });
-        result.map_err(|err| crate::errors::AuditError::from(err).into())
+        send_with_retry(
+            client,
+            event,
+            severity,
+            immutable_trail,
+            self.immutablelog.retry_enabled,
+            self.immutablelog.max_retries,
+        )
+    }
+
+    /// Seção crítica de `log()`, em Rust puro (sem GIL): trava o
+    /// `last_hash`, monta o evento já encadeado, calcula o hash, grava
+    /// local e/ou envia à rede conforme o modo, e atualiza o cache. O
+    /// lock é mantido por toda a operação — inclusive a chamada de rede
+    /// em `remote`/`hybrid` — de propósito: a cadeia de hashes é
+    /// inerentemente sequencial, então serializar `log()` é o
+    /// comportamento correto (impede duas threads de encadearem no mesmo
+    /// `previous_hash`).
+    #[allow(clippy::too_many_arguments)]
+    fn append_chained(
+        &self,
+        actor_id: String,
+        action: String,
+        resource: String,
+        resource_id: String,
+        metadata: serde_json::Value,
+        timestamp: String,
+        severity: Option<String>,
+        immutable_trail: Option<String>,
+        resolved_severity: &str,
+    ) -> Result<AuditEvent, crate::errors::AuditError> {
+        let mut guard = self.lock_last_hash();
+
+        // `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 {
+            id: Uuid::new_v4().to_string(),
+            timestamp,
+            app_name: self.app_name.clone(),
+            actor_id,
+            action,
+            resource,
+            resource_id,
+            metadata,
+            previous_hash: guard.clone(),
+            hash: String::new(),
+            severity,
+            immutable_trail,
+            immutablelog: None,
+        };
+        event.hash = compute_hash(&event)?;
+
+        match self.mode {
+            AuditMode::Local => {
+                storage::append_event(&self.file_path, &event)?;
+                *guard = Some(event.hash.clone());
+            }
+            AuditMode::Remote => {
+                // Não grava JSONL local: se o envio falhar, o erro sobe
+                // como exceção Python e `last_hash` continua apontando
+                // para o último evento que de fato foi confirmado.
+                let receipt = self
+                    .deliver(&event, resolved_severity, event.immutable_trail.as_deref())
+                    .map_err(crate::errors::AuditError::from)?;
+                event.immutablelog = Some(receipt);
+                *guard = Some(event.hash.clone());
+            }
+            AuditMode::Hybrid => {
+                // Salva local PRIMEIRO: mesmo que o processo morra antes
+                // do envio terminar, o evento já está persistido (sem
+                // receipt) — nunca perdemos o registro local por uma
+                // falha de rede.
+                storage::append_event(&self.file_path, &event)?;
+                *guard = Some(event.hash.clone());
+
+                match self.deliver(&event, resolved_severity, event.immutable_trail.as_deref()) {
+                    Ok(receipt) => {
+                        event.immutablelog = Some(receipt.clone());
+                        storage::update_event_receipt(&self.file_path, &event.id, &receipt)?;
+                    }
+                    Err(_) => {
+                        // Falha em hybrid NÃO é exceção Python: o evento
+                        // já está seguro localmente, então devolvemos
+                        // status "pending" e deixamos `flush_pending()`
+                        // tentar de novo depois.
+                        let pending_receipt = ImmutableLogReceipt::pending();
+                        event.immutablelog = Some(pending_receipt.clone());
+                        storage::update_event_receipt(&self.file_path, &event.id, &pending_receipt)?;
+                        storage::append_event(&storage::pending_path_for(&self.file_path), &event)?;
+                    }
+                }
+            }
+        }
+
+        Ok(event)
     }
 }

{rust_py_audit-0.2.2 → rust_py_audit-0.2.3}/src/pyconv.rs

@@ -36,8 +36,26 @@ pub fn python_to_json(value: &Bound<'_, PyAny>) -> PyResult<serde_json::Value> {
     }
 
     if let Ok(integer) = value.downcast::<PyInt>() {
-        let number: i64 = integer.extract()?;
-        return Ok(serde_json::Value::from(number));
+        // Python tem inteiros de precisão arbitrária; `i64` não cobre,
+        // por exemplo, IDs de 64 bits sem sinal (acima de i64::MAX) ou
+        // timestamps em nanossegundos. Tentamos `i64` primeiro (cobre
+        // negativos), depois `u64` (cobre o resto do range positivo de
+        // 64 bits) e, só então, caímos em `f64` para inteiros ainda
+        // maiores — preservando o valor (com possível perda de precisão
+        // além de 2^53, inevitável em JSON) em vez de estourar
+        // `OverflowError` e derrubar o `log()` inteiro.
+        if let Ok(number) = integer.extract::<i64>() {
+            return Ok(serde_json::Value::from(number));
+        }
+        if let Ok(number) = integer.extract::<u64>() {
+            return Ok(serde_json::Value::from(number));
+        }
+        let number: f64 = integer.extract()?;
+        return serde_json::Number::from_f64(number)
+            .map(serde_json::Value::Number)
+            .ok_or_else(|| {
+                PyTypeError::new_err("inteiro grande demais para representar em metadata")
+            });
     }
 
     if let Ok(float) = value.downcast::<PyFloat>() {
@@ -95,6 +113,12 @@ pub fn json_to_python(py: Python<'_>, value: &serde_json::Value) -> PyResult<PyO
         serde_json::Value::Number(number) => {
             if let Some(integer) = number.as_i64() {
                 Ok(integer.into_py(py))
+            } else if let Some(unsigned) = number.as_u64() {
+                // Inteiros acima de i64::MAX (ex.: IDs de 64 bits sem
+                // sinal) precisam de `as_u64` ANTES de `as_f64`, ou
+                // voltariam como float — quebrando o round-trip exato
+                // do que `python_to_json` gravou como u64.
+                Ok(unsigned.into_py(py))
             } else if let Some(float) = number.as_f64() {
                 Ok(float.into_py(py))
             } else {

{rust_py_audit-0.2.2 → rust_py_audit-0.2.3}/src/storage.rs

@@ -167,6 +167,55 @@ pub fn remove_event(path: &Path, event_id: &str) -> Result<(), AuditError> {
     rewrite_events(path, &events)
 }
 
+/// Versão em lote de `update_event_receipt`: anexa o receipt
+/// correspondente a cada evento cujo `id` esteja em `receipts`, numa
+/// ÚNICA leitura + reescrita do arquivo. `flush_pending()` usa isso para
+/// não pagar um O(n) (ler+reescrever o arquivo inteiro) por evento
+/// confirmado — o que tornaria o flush O(n*m) com `m` pendentes.
+///
+/// Relê o arquivo na hora da escrita (em vez de receber a lista pronta)
+/// de propósito: assim eventos gravados concorrentemente por um `log()`
+/// entre o início do flush e este ponto são preservados, não
+/// sobrescritos.
+pub fn update_event_receipts(
+    path: &Path,
+    receipts: &std::collections::HashMap<String, ImmutableLogReceipt>,
+) -> Result<(), AuditError> {
+    if receipts.is_empty() {
+        return Ok(());
+    }
+
+    let mut events = read_events(path)?;
+    for event in events.iter_mut() {
+        if let Some(receipt) = receipts.get(&event.id) {
+            event.immutablelog = Some(receipt.clone());
+        }
+    }
+
+    rewrite_events(path, &events)
+}
+
+/// Versão em lote de `remove_event`: remove todos os eventos cujo `id`
+/// esteja em `ids`, numa única leitura + reescrita. Remover por `id`
+/// (em vez de reescrever a fila com um snapshot antigo) preserva
+/// eventos pendentes que tenham sido acrescentados concorrentemente
+/// durante o flush.
+pub fn remove_events(
+    path: &Path,
+    ids: &std::collections::HashSet<String>,
+) -> Result<(), AuditError> {
+    if ids.is_empty() {
+        return Ok(());
+    }
+
+    let events: Vec<AuditEvent> = read_events(path)?
+        .into_iter()
+        .filter(|event| !ids.contains(&event.id))
+        .collect();
+
+    rewrite_events(path, &events)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -300,6 +349,73 @@ mod tests {
         let _ = std::fs::remove_file(&path);
     }
 
+    #[test]
+    fn update_event_receipts_applies_many_in_a_single_rewrite() {
+        let path = temp_path();
+        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");
+
+        let mut receipts = std::collections::HashMap::new();
+        receipts.insert(first.id.clone(), ImmutableLogReceipt::pending());
+        receipts.insert(
+            third.id.clone(),
+            crate::immutablelog_receipt::ImmutableLogReceipt {
+                status: "delivered".to_string(),
+                tx_id: Some("tx_3".to_string()),
+                ..Default::default()
+            },
+        );
+        update_event_receipts(&path, &receipts).expect("update em lote não deveria falhar");
+
+        let events = read_events(&path).expect("read não deveria falhar");
+        assert_eq!(events.len(), 3);
+        // Ordem preservada; só os ids no mapa ganharam receipt.
+        assert_eq!(events[0].immutablelog.as_ref().map(|r| r.status.as_str()), Some("pending"));
+        assert_eq!(events[1].immutablelog, None);
+        assert_eq!(events[2].immutablelog.as_ref().and_then(|r| r.tx_id.clone()), Some("tx_3".to_string()));
+
+        let _ = std::fs::remove_file(&path);
+    }
+
+    #[test]
+    fn remove_events_drops_only_the_matching_ids_in_one_pass() {
+        let path = temp_path();
+        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");
+
+        let mut ids = std::collections::HashSet::new();
+        ids.insert(first.id.clone());
+        ids.insert(third.id.clone());
+        remove_events(&path, &ids).expect("remove em lote não deveria falhar");
+
+        let events = read_events(&path).expect("read não deveria falhar");
+        assert_eq!(events, vec![second]);
+
+        let _ = std::fs::remove_file(&path);
+    }
+
+    #[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");
+
+        update_event_receipts(&path, &std::collections::HashMap::new()).expect("noop");
+        remove_events(&path, &std::collections::HashSet::new()).expect("noop");
+
+        let events = read_events(&path).expect("read não deveria falhar");
+        assert_eq!(events.len(), 1);
+
+        let _ = std::fs::remove_file(&path);
+    }
+
     #[test]
     fn remove_event_drops_only_the_matching_event() {
         let path = temp_path();

rust_py_audit-0.2.3/tests/test_concurrency.py

@@ -0,0 +1,76 @@
+"""
+Concorrência: várias threads compartilhando o MESMO `AuditLogger`.
+
+Cenário real: servidor WSGI multi-thread (ex.: `gunicorn --threads N`)
+compartilha uma única instância do middleware — e, portanto, um único
+`AuditLogger` — entre as threads de requisição.
+
+Antes do `AuditLogger` virar thread-safe (`&self` + `Mutex`, em vez de
+`&mut self`), uma segunda thread chamando `log()` enquanto a primeira
+tinha liberado o GIL durante a chamada de rede (`mode="remote"`/
+`"hybrid"`) recebia `RuntimeError: Already borrowed` — perdendo o evento
+silenciosamente. Estes testes travam justamente esse caso.
+"""
+import threading
+
+from rust_py_audit import AuditLogger
+
+
+def _run_concurrently(target, n):
+    errors: list[Exception] = []
+
+    def worker(i):
+        try:
+            target(i)
+        except Exception as exc:  # noqa: BLE001 — queremos capturar QUALQUER erro
+            errors.append(exc)
+
+    threads = [threading.Thread(target=worker, args=(i,)) for i in range(n)]
+    for t in threads:
+        t.start()
+    for t in threads:
+        t.join()
+    return errors
+
+
+def test_concurrent_hybrid_logging_does_not_raise_and_keeps_chain_valid(tmp_path, immutablelog_server):
+    # O delay força a sobreposição das threads: enquanto uma está no
+    # envio HTTP (GIL liberado), as outras tentam chamar `log()`.
+    immutablelog_server.set_delay(0.05)
+    audit = AuditLogger(
+        app_name="billing-api",
+        file_path=str(tmp_path / "audit.jsonl"),
+        mode="hybrid",
+        immutablelog_url=immutablelog_server.url,
+        immutablelog_api_key="iml_live_ok",
+    )
+
+    n = 12
+    errors = _run_concurrently(
+        lambda i: audit.log(actor_id=f"u{i}", action="POST", resource="/r", resource_id=str(i)),
+        n,
+    )
+
+    assert errors == [], f"log() concorrente levantou exceção(ões): {errors}"
+
+    # A cadeia precisa ter exatamente N eventos e continuar íntegra —
+    # nenhuma thread pode ter encadeado no mesmo previous_hash de outra
+    # (o que bifurcaria/quebraria a cadeia).
+    result = audit.verify()
+    assert result["valid"] is True
+    assert result["total_events"] == n
+
+
+def test_concurrent_local_logging_keeps_chain_valid(tmp_path):
+    audit = AuditLogger(app_name="billing-api", file_path=str(tmp_path / "audit.jsonl"))
+
+    n = 50
+    errors = _run_concurrently(
+        lambda i: audit.log(actor_id=f"u{i}", action="POST", resource="/r", resource_id=str(i)),
+        n,
+    )
+
+    assert errors == []
+    result = audit.verify()
+    assert result["valid"] is True
+    assert result["total_events"] == n

rust_py_audit-0.2.3/tests/test_metadata_bigint.py

@@ -0,0 +1,76 @@
+"""
+Inteiros de precisão arbitrária em `metadata`.
+
+Python permite inteiros sem limite; o core Rust precisa aceitá-los sem
+estourar `OverflowError` (regressão: antes só tentávamos `i64`). A regra
+é: `i64` -> `u64` -> `f64` (fallback para inteiros acima de 2^64, com a
+perda de precisão inevitável em JSON).
+"""
+import json
+
+from rust_py_audit import AuditLogger
+
+
+def _logger(tmp_path):
+    return AuditLogger(app_name="billing-api", file_path=str(tmp_path / "audit.jsonl"))
+
+
+def test_metadata_accepts_ints_beyond_i64_range(tmp_path):
+    audit = _logger(tmp_path)
+
+    above_i64 = 2**63 + 1  # > i64::MAX, ainda cabe em u64
+    u64_max = 2**64 - 1  # 18446744073709551615
+    negative = -(2**40)
+
+    event = audit.log(
+        actor_id="user_1",
+        action="LOGIN",
+        resource="session",
+        resource_id="s1",
+        metadata={"above_i64": above_i64, "u64_max": u64_max, "negative": negative},
+    )
+
+    # Round-trip exato, sem virar float nem estourar.
+    assert event["metadata"]["above_i64"] == above_i64
+    assert isinstance(event["metadata"]["above_i64"], int)
+    assert event["metadata"]["u64_max"] == u64_max
+    assert isinstance(event["metadata"]["u64_max"], int)
+    assert event["metadata"]["negative"] == negative
+
+
+def test_metadata_bigint_persists_and_chain_stays_valid(tmp_path):
+    file_path = tmp_path / "audit.jsonl"
+    audit = _logger(tmp_path)
+
+    audit.log(
+        actor_id="user_1",
+        action="LOGIN",
+        resource="session",
+        resource_id="s1",
+        metadata={"snowflake": 2**63 + 12345},
+    )
+
+    # O valor grande precisa ter sido gravado como número JSON inteiro
+    # (entra no hash), e a cadeia tem que continuar verificável.
+    persisted = json.loads(file_path.read_text().strip())
+    assert persisted["metadata"]["snowflake"] == 2**63 + 12345
+
+    assert audit.verify()["valid"] is True
+
+
+def test_metadata_int_above_u64_falls_back_to_float(tmp_path):
+    audit = _logger(tmp_path)
+
+    huge = 2**100  # acima de u64::MAX -> só representável como float
+
+    event = audit.log(
+        actor_id="user_1",
+        action="LOGIN",
+        resource="session",
+        resource_id="s1",
+        metadata={"huge": huge},
+    )
+
+    assert isinstance(event["metadata"]["huge"], float)
+    assert event["metadata"]["huge"] == float(huge)
+    assert audit.verify()["valid"] is True