Struct Instrumented 

pub struct Instrumented<'a, B> { /* private fields */ }

A BlobBackend that counts what the wrapped backend does, per operation. It changes nothing.

Implementations

impl<'a, B: BlobBackend> Instrumented<'a, B>

pub fn new(inner: &'a B) -> Self

Wrap inner.

pub fn counts(&self) -> BTreeMap<&'static str, OpCount>

The counts so far, by operation name (read, write, append, …).

Trait Implementations

impl<B: BlobBackend> BlobBackend for Instrumented<'_, B>

fn backend(&self) -> &str

The backend’s name as it appears in matrix rows (memory, fs, s3).

fn version(&self) -> &str

The backend’s version string as it appears in matrix rows.

async fn read(&self, key: &str) -> Result<Option<Vec<u8>>, BlobError>

The value at key, or None if absent.

async fn write(&self, key: &str, bytes: Vec<u8>) -> Result<(), BlobError>

Store bytes at key, replacing any earlier value. Atomicity is not implied; that is blob.replace_atomic.

async fn delete(&self, key: &str) -> Result<(), BlobError>

Remove key. Removing an absent key is Ok.

async fn stat(&self, key: &str) -> Result<Option<Entry>, BlobError>

The entry at key without reading its value, or None if absent.

async fn list( &self, prefix: &str, after: Option<&str>, limit: usize, ) -> Result<Page, BlobError>

Up to limit entries whose key starts with the literal prefix, in ascending bytewise key order, strictly after after if given.

async fn create_exclusive( &self, key: &str, bytes: Vec<u8>, ) -> Result<bool, BlobError>

Write bytes at key only if nothing is there. Ok(true) created it, Ok(false) found a value and changed nothing. Of any number of concurrent callers for one key, exactly one gets Ok(true) (blob.create_exclusive). A backend that cannot promise that returns BlobError::Unsupported; the default does.

async fn replace_atomic( &self, key: &str, bytes: Vec<u8>, ) -> Result<(), BlobError>

Replace the value at key so that a concurrent reader sees the whole old value or the whole new one, never a mix (blob.replace_atomic.concurrent_read). A backend that cannot promise that returns BlobError::Unsupported; the default does.

async fn append(&self, key: &str, bytes: Vec<u8>) -> Result<(), BlobError>

Add bytes after the existing bytes of key, in call order (blob.append). Of concurrent calls, each call’s bytes arrive whole and exactly once (blob.append.concurrent_whole). A backend that cannot promise that returns BlobError::Unsupported; the default does.

impl<'a, B: Debug> Debug for Instrumented<'a, B>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.