Struct AccessLogHook 

pub struct AccessLogHook { /* private fields */ }

A DispatchHook that writes one JSON line per call to an arbitrary Write sink. Entries carry the vgi_rpc.access logger name so the Python validator’s filter (.logger == "vgi_rpc.access") matches.

Two modes:

• AccessLogHook::new / [to_stderr] write synchronously on the dispatch thread (acceptable for stderr or in-memory test sinks).
• AccessLogHook::buffered queues into a bounded mpsc channel and drains on a background thread; on overflow it drops the entry and bumps a counter rather than blocking dispatch.

Implementations

impl AccessLogHook

pub fn new<W: Write + Send + 'static>( sink: W, server_version: impl Into<String>, ) -> Arc<Self>

Create an access log hook that writes synchronously to sink. Suitable for stderr or in-memory sinks; for production file I/O prefer AccessLogHook::buffered to keep dispatch threads off the disk path.

pub fn with_verbose(self: Arc<Self>, verbose: bool) -> Arc<Self>

Return a new Arc<AccessLogHook> with verbose request-data emission enabled. Mirrors Python’s _access_logger.isEnabledFor(logging.DEBUG) behaviour where the full base64-encoded request batch is included verbatim rather than being elided via truncated: true.

pub fn buffered<W: Write + Send + 'static>( sink: W, server_version: impl Into<String>, capacity: usize, ) -> Arc<Self>

Create a hook that writes asynchronously: the dispatch thread pushes a formatted line into a bounded channel of capacity entries and a background thread drains it into sink. When the channel is full, the entry is dropped (counted by dropped_count) instead of blocking dispatch — this is the right tradeoff for high-throughput servers where occasional log loss is preferable to head-of-line blocking behind a stalled disk.

The writer thread exits when the hook is dropped (sender closes).

pub fn to_stderr(server_version: impl Into<String>) -> Arc<Self>

Convenience: write access logs to stderr synchronously (one JSON line per entry).

pub fn dropped_count(&self) -> u64

Number of entries dropped because the async channel was full. Always zero for synchronous hooks.

Trait Implementations

impl DispatchHook for AccessLogHook

fn on_dispatch_start(&self, _info: &DispatchInfo) -> HookToken

Invoked just before the handler runs. Return a token that will be passed to on_dispatch_end.

fn on_dispatch_end( &self, token: HookToken, info: &DispatchInfo, error: Option<&RpcError>, stats: &CallStatistics, )

Invoked once the handler has returned and all logs/batches have been written to the transport.