export queue capacity

src/lib.rs

@@ -28,6 +28,17 @@ impl<'a> Record<'a> {
     }
 }
 
+/// Resources used by mrecordlog
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ResourceUsage {
+    /// Actual size of the memory used
+    pub memory_used_bytes: usize,
+    /// Capacity allocated, a part of which may be unused right now
+    pub memory_allocated_bytes: usize,
+    /// Disk size used
+    pub disk_used_bytes: usize,
+}
+
 #[cfg(test)]
 mod tests;
 

src/mem/queue.rs

@@ -22,6 +22,10 @@ impl RollingBuffer {
         self.buffer.len()
     }
 
+    fn capacity(&self) -> usize {
+        self.buffer.capacity()
+    }
+
     fn clear(&mut self) {
         self.buffer.clear();
         self.buffer.shrink_to_fit();
@@ -250,4 +254,9 @@ impl MemQueue {
         self.concatenated_records.len()
             + self.record_metas.len() * std::mem::size_of::<RecordMeta>()
     }
+
+    pub fn capacity(&self) -> usize {
+        self.concatenated_records.capacity()
+            + self.record_metas.capacity() * std::mem::size_of::<RecordMeta>()
+    }
 }

src/mem/queues.rs

@@ -154,10 +154,20 @@ impl MemQueues {
         }
     }
 
-    pub fn size(&self) -> usize {
-        self.queues
+    /// Return a tuple of (size, capacity) of memory used by the memqueues
+    pub fn size(&self) -> (usize, usize) {
+        let size = self
+            .queues
             .iter()
             .map(|(name, queue)| name.len() + queue.size())
-            .sum()
+            .sum();
+
+        let capacity = self
+            .queues
+            .iter()
+            .map(|(name, queue)| name.capacity() + queue.capacity())
+            .sum();
+
+        (size, capacity)
     }
 }

src/multi_record_log.rs

@@ -13,7 +13,7 @@ use crate::mem::MemQueue;
 use crate::record::{MultiPlexedRecord, MultiRecord};
 use crate::recordlog::RecordWriter;
 use crate::rolling::RollingWriter;
-use crate::{mem, Record};
+use crate::{mem, Record, ResourceUsage};
 
 pub struct MultiRecordLog {
     record_log_writer: crate::recordlog::RecordWriter<RollingWriter>,
@@ -355,17 +355,14 @@ impl MultiRecordLog {
         self.in_mem_queues.last_record(queue)
     }
 
-    /// Returns the quantity of data stored in the in memory queue.
-    pub fn memory_usage(&self) -> usize {
-        self.in_mem_queues.size()
-    }
-
-    /// Returns the used disk space.
-    ///
-    /// This is typically higher than what [`Self::memory_usage`] reports as records are first
-    /// marked as truncated, and only get deleted once all other records in the same file are
-    /// truncated too.
-    pub fn disk_usage(&self) -> usize {
-        self.record_log_writer.size()
+    /// Return the amount of memory and disk space used by mrecordlog.
+    pub fn resource_usage(&self) -> ResourceUsage {
+        let disk_used_bytes = self.record_log_writer.size();
+        let (memory_used_bytes, memory_allocated_bytes) = self.in_mem_queues.size();
+        ResourceUsage {
+            memory_used_bytes,
+            memory_allocated_bytes,
+            disk_used_bytes,
+        }
     }
 }

src/tests.rs

@@ -323,21 +323,25 @@ fn test_multi_record_size() {
     let tempdir = tempfile::tempdir().unwrap();
     {
         let mut multi_record_log = MultiRecordLog::open(tempdir.path()).unwrap();
-        assert_eq!(multi_record_log.memory_usage(), 0);
+        assert_eq!(multi_record_log.resource_usage().memory_used_bytes, 0);
+        assert_eq!(multi_record_log.resource_usage().memory_allocated_bytes, 0);
 
         multi_record_log.create_queue("queue").unwrap();
-        let size_mem_create = multi_record_log.memory_usage();
-        assert!(size_mem_create > 0);
+        let size_mem_create = multi_record_log.resource_usage();
+        assert!(size_mem_create.memory_used_bytes > 0);
+        assert!(size_mem_create.memory_allocated_bytes >= size_mem_create.memory_used_bytes);
 
         multi_record_log
             .append_record("queue", None, &b"hello"[..])
             .unwrap();
-        let size_mem_append = multi_record_log.memory_usage();
-        assert!(size_mem_append > size_mem_create);
+        let size_mem_append = multi_record_log.resource_usage();
+        assert!(size_mem_append.memory_used_bytes > size_mem_create.memory_used_bytes);
+        assert!(size_mem_append.memory_allocated_bytes >= size_mem_append.memory_used_bytes);
+        assert!(size_mem_append.memory_allocated_bytes >= size_mem_create.memory_allocated_bytes);
 
         multi_record_log.truncate("queue", 0).unwrap();
-        let size_mem_truncate = multi_record_log.memory_usage();
-        assert!(size_mem_truncate < size_mem_append);
+        let size_mem_truncate = multi_record_log.resource_usage();
+        assert!(size_mem_truncate.memory_used_bytes < size_mem_append.memory_used_bytes);
     }
 }