dcontext 0.5.0

Distributed context propagation for Rust — scoped, type-safe, serializable
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

use std::sync::atomic::{AtomicUsize, Ordering};

/// 0 means no limit.
static MAX_CONTEXT_SIZE: AtomicUsize = AtomicUsize::new(0);

/// Default scope chain length limit.
const DEFAULT_MAX_SCOPE_CHAIN_LEN: usize = 64;

/// 0 means no limit; non-zero caps the scope chain to that many entries.
static MAX_SCOPE_CHAIN_LEN: AtomicUsize = AtomicUsize::new(DEFAULT_MAX_SCOPE_CHAIN_LEN);

/// Set the maximum serialized context size in bytes.
/// Serialization functions will return `ContextTooLarge` if exceeded.
/// Set to 0 to disable (default).
pub fn set_max_context_size(limit: usize) {
    MAX_CONTEXT_SIZE.store(limit, Ordering::Relaxed);
}

/// Get the current max context size limit. 0 means no limit.
pub fn max_context_size() -> usize {
    MAX_CONTEXT_SIZE.load(Ordering::Relaxed)
}

/// Check if a serialized size exceeds the configured limit.
/// Returns Ok(()) if within limit or no limit set.
pub(crate) fn check_size(size: usize) -> Result<(), crate::error::ContextError> {
    let limit = max_context_size();
    if limit > 0 && size > limit {
        Err(crate::error::ContextError::ContextTooLarge { size, limit })
    } else {
        Ok(())
    }
}

/// Set the maximum number of entries in the scope chain.
///
/// When the chain exceeds this limit, the oldest entries (from the remote
/// prefix) are dropped to keep the most recent scopes visible.
/// Set to 0 to disable the limit. Default is 64.
pub fn set_max_scope_chain_len(limit: usize) {
    MAX_SCOPE_CHAIN_LEN.store(limit, Ordering::Relaxed);
}

/// Get the current max scope chain length. 0 means no limit. Default is 64.
pub fn max_scope_chain_len() -> usize {
    MAX_SCOPE_CHAIN_LEN.load(Ordering::Relaxed)
}