From bc2c40d93ccf2f7f583a86f2ea5afcd2c61a7ed3 Mon Sep 17 00:00:00 2001 From: xzfc <5121426+xzfc@users.noreply.github.com> Date: Thu, 2 Jul 2026 07:50:07 +0000 Subject: [PATCH] Tidy up Debug impls (#9653) --- lib/common/common/src/mmap/mmap_readonly.rs | 8 ++++-- lib/common/common/src/mmap/mmap_rw.rs | 8 +++--- .../persisted_hashmap/uio/random_reader.rs | 6 +++- lib/common/common/src/universal_io/oneshot.rs | 5 ++-- .../simple_disk_cache/file/mod.rs | 19 +++++++++---- .../src/universal_io/simple_disk_cache/fs.rs | 5 ++-- .../simple_disk_cache/pipeline.rs | 9 ++++-- .../src/universal_io/wrappers/read_only.rs | 3 +- .../common/src/universal_io/wrappers/typed.rs | 3 +- lib/common/io_bridge/src/file.rs | 9 ++++-- lib/common/io_bridge/src/fs.rs | 3 +- .../src/common/flags/dynamic_stored_flags.rs | 15 ++++++---- .../volatile_multi_dense_vector_storage.rs | 21 ++++++++++---- .../quantized/quantized_vectors/config.rs | 7 ++++- .../quantized_vectors/read_only/storage.rs | 3 +- .../quantized/quantized_vectors/storage.rs | 3 +- lib/segment/src/vector_storage/turbo/mod.rs | 17 ++++++++--- lib/segment/src/vector_storage/turbo/multi.rs | 19 ++++++++++--- lib/shard/src/segment_holder/mod.rs | 9 ++++-- lib/wal/src/lib.rs | 27 ++++++++++-------- lib/wal/src/mmap_view_sync.rs | 14 ++++++---- lib/wal/src/segment.rs | 28 ++++++++++++------- lib/wal/src/test_utils.rs | 15 ++++++---- 23 files changed, 176 insertions(+), 80 deletions(-) diff --git a/lib/common/common/src/mmap/mmap_readonly.rs b/lib/common/common/src/mmap/mmap_readonly.rs index 82ae5cc9b7..33c764cfc3 100644 --- a/lib/common/common/src/mmap/mmap_readonly.rs +++ b/lib/common/common/src/mmap/mmap_readonly.rs @@ -73,8 +73,9 @@ where impl fmt::Debug for MmapTypeReadOnly { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let Self { mmap, r#type: _ } = self; f.debug_struct("MmapTypeReadOnly") - .field("mmap", &self.mmap) + .field("mmap", mmap) .finish_non_exhaustive() } } @@ -299,9 +300,10 @@ where impl fmt::Debug for MmapSliceReadOnly { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let Self { mmap } = self; f.debug_struct("MmapSliceReadOnly") - .field("mmap", &self.mmap) - .finish_non_exhaustive() + .field("mmap", mmap) + .finish() } } diff --git a/lib/common/common/src/mmap/mmap_rw.rs b/lib/common/common/src/mmap/mmap_rw.rs index 72ce2d0621..f4ee1a5c39 100644 --- a/lib/common/common/src/mmap/mmap_rw.rs +++ b/lib/common/common/src/mmap/mmap_rw.rs @@ -78,8 +78,9 @@ where impl fmt::Debug for MmapType { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let Self { mmap, r#type: _ } = self; f.debug_struct("MmapType") - .field("mmap", &self.mmap) + .field("mmap", mmap) .finish_non_exhaustive() } } @@ -236,9 +237,8 @@ where impl fmt::Debug for MmapSlice { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.debug_struct("MmapSlice") - .field("mmap", &self.mmap) - .finish_non_exhaustive() + let Self { mmap } = self; + f.debug_struct("MmapSlice").field("mmap", mmap).finish() } } diff --git a/lib/common/common/src/persisted_hashmap/uio/random_reader.rs b/lib/common/common/src/persisted_hashmap/uio/random_reader.rs index 8bb8946845..9d907aa78a 100644 --- a/lib/common/common/src/persisted_hashmap/uio/random_reader.rs +++ b/lib/common/common/src/persisted_hashmap/uio/random_reader.rs @@ -41,8 +41,12 @@ struct Entry<'a, U: UserData, K: Key + ?Sized> { // buffers and key references that are not `Debug`. impl std::fmt::Debug for Entry<'_, U, K> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let Self { + user_data, + state: _, + } = self; f.debug_struct("Entry") - .field("user_data", &self.user_data) + .field("user_data", user_data) .finish_non_exhaustive() } } diff --git a/lib/common/common/src/universal_io/oneshot.rs b/lib/common/common/src/universal_io/oneshot.rs index 5d948699d5..3c9df55fcf 100644 --- a/lib/common/common/src/universal_io/oneshot.rs +++ b/lib/common/common/src/universal_io/oneshot.rs @@ -51,9 +51,8 @@ impl Deref for OneshotFile { impl fmt::Debug for OneshotFile { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.debug_struct("OneshotFile") - .field("inner", &self.inner) - .finish() + let Self { inner } = self; + f.debug_struct("OneshotFile").field("inner", inner).finish() } } diff --git a/lib/common/common/src/universal_io/simple_disk_cache/file/mod.rs b/lib/common/common/src/universal_io/simple_disk_cache/file/mod.rs index f042ac7b13..317e105a98 100644 --- a/lib/common/common/src/universal_io/simple_disk_cache/file/mod.rs +++ b/lib/common/common/src/universal_io/simple_disk_cache/file/mod.rs @@ -72,12 +72,21 @@ where R: UniversalRead, { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let Self { + remote_fs, + remote_path, + open_options, + local_path, + state, + remote_extra: _, + init_lock: _, + } = self; f.debug_struct("DiskCache") - .field("remote_fs", &self.remote_fs) - .field("remote_path", &self.remote_path) - .field("open_options", &self.open_options) - .field("local_path", &self.local_path) - .field("state", &self.state) + .field("remote_fs", remote_fs) + .field("remote_path", remote_path) + .field("open_options", open_options) + .field("local_path", local_path) + .field("state", state) .finish_non_exhaustive() } } diff --git a/lib/common/common/src/universal_io/simple_disk_cache/fs.rs b/lib/common/common/src/universal_io/simple_disk_cache/fs.rs index 03a760b74c..40e2d72f68 100644 --- a/lib/common/common/src/universal_io/simple_disk_cache/fs.rs +++ b/lib/common/common/src/universal_io/simple_disk_cache/fs.rs @@ -56,9 +56,10 @@ where R: UniversalRead, { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let Self { config, remote_fs } = self; f.debug_struct("DiskCacheFs") - .field("config", &self.config) - .field("remote_fs", &self.remote_fs) + .field("config", config) + .field("remote_fs", remote_fs) .finish() } } diff --git a/lib/common/common/src/universal_io/simple_disk_cache/pipeline.rs b/lib/common/common/src/universal_io/simple_disk_cache/pipeline.rs index 8b34eeb665..9e1ecef4a0 100644 --- a/lib/common/common/src/universal_io/simple_disk_cache/pipeline.rs +++ b/lib/common/common/src/universal_io/simple_disk_cache/pipeline.rs @@ -26,9 +26,14 @@ struct RemoteMeta { impl fmt::Debug for RemoteMeta { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let Self { + scheduled_read, + user_data, + file: _, + } = self; f.debug_struct("RemoteMeta") - .field("scheduled_read", &self.scheduled_read) - .field("user_data", &self.user_data) + .field("scheduled_read", scheduled_read) + .field("user_data", user_data) .finish_non_exhaustive() } } diff --git a/lib/common/common/src/universal_io/wrappers/read_only.rs b/lib/common/common/src/universal_io/wrappers/read_only.rs index 1b4a5abbfd..12e9642e7b 100644 --- a/lib/common/common/src/universal_io/wrappers/read_only.rs +++ b/lib/common/common/src/universal_io/wrappers/read_only.rs @@ -31,7 +31,8 @@ pub struct ReadOnlyFs(F); impl fmt::Debug for ReadOnlyFs { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.debug_tuple("ReadOnlyFs").field(&self.0).finish() + let Self(inner) = self; + f.debug_tuple("ReadOnlyFs").field(inner).finish() } } diff --git a/lib/common/common/src/universal_io/wrappers/typed.rs b/lib/common/common/src/universal_io/wrappers/typed.rs index fcefa474e3..3c8bcd12b7 100644 --- a/lib/common/common/src/universal_io/wrappers/typed.rs +++ b/lib/common/common/src/universal_io/wrappers/typed.rs @@ -27,8 +27,9 @@ pub struct TypedStorage { impl fmt::Debug for TypedStorage { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let Self { inner, _phantom: _ } = self; f.debug_struct("TypedStorage") - .field("inner", &self.inner) + .field("inner", inner) .finish() } } diff --git a/lib/common/io_bridge/src/file.rs b/lib/common/io_bridge/src/file.rs index 2598a865a8..22e0bda4b6 100644 --- a/lib/common/io_bridge/src/file.rs +++ b/lib/common/io_bridge/src/file.rs @@ -26,9 +26,14 @@ pub struct BlobFile { impl std::fmt::Debug for BlobFile { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let Self { + runtime, + path, + inner: _, + } = self; f.debug_struct("BlobFile") - .field("runtime", &self.runtime) - .field("path", &self.path) + .field("runtime", runtime) + .field("path", path) .finish_non_exhaustive() } } diff --git a/lib/common/io_bridge/src/fs.rs b/lib/common/io_bridge/src/fs.rs index 9e7ccb5219..14251db0e2 100644 --- a/lib/common/io_bridge/src/fs.rs +++ b/lib/common/io_bridge/src/fs.rs @@ -17,8 +17,9 @@ pub struct BlobFs { impl std::fmt::Debug for BlobFs { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let Self { runtime, inner: _ } = self; f.debug_struct("BlobFs") - .field("runtime", &self.runtime) + .field("runtime", runtime) .finish_non_exhaustive() } } diff --git a/lib/segment/src/common/flags/dynamic_stored_flags.rs b/lib/segment/src/common/flags/dynamic_stored_flags.rs index 8b6ad8d565..f9ae74b206 100644 --- a/lib/segment/src/common/flags/dynamic_stored_flags.rs +++ b/lib/segment/src/common/flags/dynamic_stored_flags.rs @@ -70,11 +70,16 @@ pub struct DynamicStoredFlags { impl fmt::Debug for DynamicStoredFlags { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.debug_struct("DynamicMmapFlags") - .field("flags", &self.flags) - .field("status", &self.status) - .field("directory", &self.directory) - .finish_non_exhaustive() + let Self { + flags, + status, + directory, + } = self; + f.debug_struct("DynamicStoredFlags") + .field("flags", flags) + .field("status", status) + .field("directory", directory) + .finish() } } diff --git a/lib/segment/src/vector_storage/multi_dense/volatile_multi_dense_vector_storage.rs b/lib/segment/src/vector_storage/multi_dense/volatile_multi_dense_vector_storage.rs index 348b4ee831..9f7bbf8909 100644 --- a/lib/segment/src/vector_storage/multi_dense/volatile_multi_dense_vector_storage.rs +++ b/lib/segment/src/vector_storage/multi_dense/volatile_multi_dense_vector_storage.rs @@ -46,13 +46,22 @@ pub struct VolatileMultiDenseVectorStorage { impl fmt::Debug for VolatileMultiDenseVectorStorage { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let Self { + dim, + distance, + multi_vector_config, + vectors, + vectors_metadata, + deleted_count, + deleted: _, + } = self; f.debug_struct("VolatileMultiDenseVectorStorage") - .field("dim", &self.dim) - .field("distance", &self.distance) - .field("multi_vector_config", &self.multi_vector_config) - .field("vectors", &self.vectors) - .field("vectors_metadata", &self.vectors_metadata) - .field("deleted_count", &self.deleted_count) + .field("dim", dim) + .field("distance", distance) + .field("multi_vector_config", multi_vector_config) + .field("vectors", vectors) + .field("vectors_metadata", vectors_metadata) + .field("deleted_count", deleted_count) .finish_non_exhaustive() } } diff --git a/lib/segment/src/vector_storage/quantized/quantized_vectors/config.rs b/lib/segment/src/vector_storage/quantized/quantized_vectors/config.rs index 24a8d5511a..87491b041f 100644 --- a/lib/segment/src/vector_storage/quantized/quantized_vectors/config.rs +++ b/lib/segment/src/vector_storage/quantized/quantized_vectors/config.rs @@ -27,8 +27,13 @@ pub struct QuantizedVectorsConfig { impl fmt::Debug for QuantizedVectorsConfig { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let Self { + quantization_config, + vector_parameters: _, + storage_type: _, + } = self; f.debug_struct("QuantizedVectorsConfig") - .field("quantization_config", &self.quantization_config) + .field("quantization_config", quantization_config) .finish_non_exhaustive() } } diff --git a/lib/segment/src/vector_storage/quantized/quantized_vectors/read_only/storage.rs b/lib/segment/src/vector_storage/quantized/quantized_vectors/read_only/storage.rs index 8834ac6bb9..93cf00af8f 100644 --- a/lib/segment/src/vector_storage/quantized/quantized_vectors/read_only/storage.rs +++ b/lib/segment/src/vector_storage/quantized/quantized_vectors/read_only/storage.rs @@ -107,7 +107,8 @@ pub enum ReadOnlyQuantizedVectorStorage { impl fmt::Debug for ReadOnlyQuantizedVectorStorage { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.debug_tuple("ReadOnlyQuantizedVectorStorage").finish() + f.debug_tuple("ReadOnlyQuantizedVectorStorage") + .finish_non_exhaustive() } } diff --git a/lib/segment/src/vector_storage/quantized/quantized_vectors/storage.rs b/lib/segment/src/vector_storage/quantized/quantized_vectors/storage.rs index 8393d8e52c..4bdf68a920 100644 --- a/lib/segment/src/vector_storage/quantized/quantized_vectors/storage.rs +++ b/lib/segment/src/vector_storage/quantized/quantized_vectors/storage.rs @@ -172,7 +172,8 @@ impl QuantizedVectorStorage { impl fmt::Debug for QuantizedVectorStorage { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.debug_tuple("QuantizedVectorStorage").finish() + f.debug_tuple("QuantizedVectorStorage") + .finish_non_exhaustive() } } diff --git a/lib/segment/src/vector_storage/turbo/mod.rs b/lib/segment/src/vector_storage/turbo/mod.rs index 9a0e5426f4..7cbf766ff5 100644 --- a/lib/segment/src/vector_storage/turbo/mod.rs +++ b/lib/segment/src/vector_storage/turbo/mod.rs @@ -187,11 +187,20 @@ impl TurboVectorStorage { impl std::fmt::Debug for TurboVectorStorage { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let Self { + dim, + distance, + storage, + deleted_count, + quantizer: _, + deleted: _, + quantization_buffer: _, + } = self; f.debug_struct("TurboVectorStorage") - .field("dim", &self.dim) - .field("distance", &self.distance) - .field("total_vector_count", &self.storage.vectors_count()) - .field("deleted_count", &self.deleted_count) + .field("dim", dim) + .field("distance", distance) + .field("total_vector_count", &storage.vectors_count()) + .field("deleted_count", deleted_count) .finish_non_exhaustive() } } diff --git a/lib/segment/src/vector_storage/turbo/multi.rs b/lib/segment/src/vector_storage/turbo/multi.rs index 22938c1712..7933aabf33 100644 --- a/lib/segment/src/vector_storage/turbo/multi.rs +++ b/lib/segment/src/vector_storage/turbo/multi.rs @@ -74,11 +74,22 @@ pub struct TurboMultiVectorStorage { impl std::fmt::Debug for TurboMultiVectorStorage { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let Self { + dim, + distance, + offsets, + deleted_count, + storage: _, + quantizer: _, + deleted: _, + multi_vector_config: _, + quantization_buffer: _, + } = self; f.debug_struct("TurboMultiVectorStorage") - .field("dim", &self.dim) - .field("distance", &self.distance) - .field("total_vector_count", &self.offsets.len()) - .field("deleted_count", &self.deleted_count) + .field("dim", dim) + .field("distance", distance) + .field("total_vector_count", &offsets.len()) + .field("deleted_count", deleted_count) .finish_non_exhaustive() } } diff --git a/lib/shard/src/segment_holder/mod.rs b/lib/shard/src/segment_holder/mod.rs index 10f7093da0..73517d0f38 100644 --- a/lib/shard/src/segment_holder/mod.rs +++ b/lib/shard/src/segment_holder/mod.rs @@ -65,9 +65,14 @@ struct DeferredAction { impl std::fmt::Debug for DeferredAction { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let Self { + ready_at, + ack_pin, + action: _, + } = self; f.debug_struct("DeferredAction") - .field("ready_at", &self.ready_at) - .field("ack_pin", &self.ack_pin) + .field("ready_at", ready_at) + .field("ack_pin", ack_pin) .finish_non_exhaustive() } } diff --git a/lib/wal/src/lib.rs b/lib/wal/src/lib.rs index 46fbf763f6..8ceb25674e 100644 --- a/lib/wal/src/lib.rs +++ b/lib/wal/src/lib.rs @@ -557,19 +557,24 @@ impl Wal { impl fmt::Debug for Wal { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let start_index = self - .closed_segments + let Self { + open_segment, + closed_segments, + path, + creator: _, + retain_closed: _, + dir: _, + flush: _, + } = self; + let start_index = closed_segments .first() .map_or(0, |segment| segment.start_index); - let end_index = self.open_segment_start_index() + self.open_segment.segment.len() as u64; - write!( - f, - "Wal {{ path: {:?}, segment-count: {}, entries: [{}, {}) }}", - &self.path, - self.closed_segments.len() + 1, - start_index, - end_index - ) + let end_index = self.open_segment_start_index() + open_segment.segment.len() as u64; + f.debug_struct("Wal") + .field("path", path) + .field("segment-count", &(closed_segments.len() + 1)) + .field("entries", &format_args!("[{start_index}, {end_index})")) + .finish_non_exhaustive() } } diff --git a/lib/wal/src/mmap_view_sync.rs b/lib/wal/src/mmap_view_sync.rs index 1b82d4ed65..471af766b1 100644 --- a/lib/wal/src/mmap_view_sync.rs +++ b/lib/wal/src/mmap_view_sync.rs @@ -174,11 +174,15 @@ impl From for MmapViewSync { impl fmt::Debug for MmapViewSync { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!( - f, - "MmapViewSync {{ offset: {}, len: {} }}", - self.offset, self.len - ) + let Self { + offset, + len, + inner: _, + } = self; + f.debug_struct("MmapViewSync") + .field("offset", offset) + .field("len", len) + .finish_non_exhaustive() } } diff --git a/lib/wal/src/segment.rs b/lib/wal/src/segment.rs index 534f0e0c12..4f03d51671 100644 --- a/lib/wal/src/segment.rs +++ b/lib/wal/src/segment.rs @@ -38,7 +38,8 @@ impl Deref for Entry { impl fmt::Debug for Entry { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "Entry {{ len: {} }}", self.view.len()) + let Self { view } = self; + f.debug_struct("Entry").field("len", &view.len()).finish() } } @@ -680,15 +681,22 @@ impl Segment { impl fmt::Debug for Segment { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!( - f, - "Segment {{ path: {:?}, flush_offset: {}, entries: {}, space: ({}/{}) }}", - &self.path, - self.flush_offset, - self.len(), - self.size(), - self.capacity() - ) + let Self { + path, + flush_offset, + mmap: _, + index: _, + crc: _, + } = self; + f.debug_struct("Segment") + .field("path", path) + .field("flush_offset", flush_offset) + .field("entries", &self.len()) + .field( + "space", + &format_args!("({}/{})", self.size(), self.capacity()), + ) + .finish_non_exhaustive() } } diff --git a/lib/wal/src/test_utils.rs b/lib/wal/src/test_utils.rs index e891916e23..0d8d2743ce 100644 --- a/lib/wal/src/test_utils.rs +++ b/lib/wal/src/test_utils.rs @@ -79,11 +79,16 @@ impl Iterator for EntryGenerator { impl fmt::Debug for EntryGenerator { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!( - f, - "EntryGenerator {{ seed: {}, remaining_size: {} }}", - self.seed, self.remaining_size - ) + let Self { + seed, + remaining_size, + rng: _, + dist: _, + } = self; + f.debug_struct("EntryGenerator") + .field("seed", seed) + .field("remaining_size", remaining_size) + .finish_non_exhaustive() } }