Struct MemoryStats

pub struct MemoryStats {

    pub peak_allocated: usize,
    pub total_allocated: usize,
    pub startup_allocated: usize,
    pub replication_backlog: usize,
    pub clients_slaves: usize,
    pub clients_normal: usize,
    pub cluster_links: usize,
    pub aof_buffer: usize,
    pub lua_caches: usize,
    pub functions_caches: usize,
    pub databases: HashMap<usize, DatabaseOverhead>,
    pub overhead_total: usize,
    pub keys_count: usize,
    pub keys_bytes_per_key: usize,
    pub dataset_bytes: usize,
    pub dataset_percentage: f64,
    pub peak_percentage: f64,
    pub allocator_allocated: usize,
    pub allocator_active: usize,
    pub allocator_resident: usize,
    pub allocator_fragmentation_ratio: f64,
    pub allocator_fragmentation_bytes: usize,
    pub allocator_rss_ratio: f64,
    pub allocator_rss_bytes: usize,
    pub rss_overhead_ratio: f64,
    pub rss_overhead_bytes: usize,
    pub fragmentation: f64,
    pub fragmentation_bytes: usize,
    pub additional_stats: HashMap<String, Value>,
}

Result for the memory_stats command.

Fields

peak_allocated: usize

Peak memory consumed by Redis in bytes (see INFO’s used_memory_peak)

total_allocated: usize

Total number of bytes allocated by Redis using its allocator (see INFO’s used_memory)

startup_allocated: usize

Initial amount of memory consumed by Redis at startup in bytes (see INFO’s used_memory_startup)

replication_backlog: usize

Size in bytes of the replication backlog (see INFO’s repl_backlog_active)

clients_slaves: usize

The total size in bytes of all replicas overheads (output and query buffers, connection contexts)

clients_normal: usize

The total size in bytes of all clients overheads (output and query buffers, connection contexts)

cluster_links: usize

Memory usage by cluster links (Added in Redis 7.0, see INFO’s mem_cluster_links).

aof_buffer: usize

The summed size in bytes of AOF related buffers.

lua_caches: usize

the summed size in bytes of the overheads of the Lua scripts’ caches

functions_caches: usize

the summed size in bytes of the overheads of the functions’ caches

databases: HashMap<usize, DatabaseOverhead>

For each of the server’s databases (key = db index), the overheads of the main and expiry dictionaries are reported in bytes

overhead_total: usize

The sum of all overheads, i.e. startup.allocated, replication.backlog, clients.slaves, clients.normal, aof.buffer and those of the internal data structures that are used in managing the Redis keyspace (see INFO’s used_memory_overhead)

keys_count: usize

The total number of keys stored across all databases in the server

keys_bytes_per_key: usize

The ratio between net memory usage (total.allocated minus startup.allocated) and keys.count

dataset_bytes: usize

The size in bytes of the dataset, i.e. overhead.total subtracted from total.allocated (see INFO’s used_memory_dataset)

dataset_percentage: f64

The percentage of dataset.bytes out of the net memory usage

peak_percentage: f64

The percentage of peak.allocated out of total.allocated

allocator_allocated: usize

allocator_active: usize

allocator_resident: usize

allocator_fragmentation_ratio: f64

allocator_fragmentation_bytes: usize

allocator_rss_ratio: f64

allocator_rss_bytes: usize

rss_overhead_ratio: f64

rss_overhead_bytes: usize

fragmentation: f64

See INFO’s mem_fragmentation_ratio

fragmentation_bytes: usize

additional_stats: HashMap<String, Value>

Trait Implementations

impl Debug for MemoryStats

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

Formats the value using the given formatter.

impl FromValue for MemoryStats

fn from_value(value: Value) -> Result<Self>

Used to do Value to user type conversion

fn from_value_with_command(value: Value, _command: &Command) -> Result<Self>

fn next_functor<I: Iterator<Item = Value>>() -> Box<dyn FnMut(&mut I) -> Option<Result<Self>>>