misc(ledger): use LoggableError to log storage problems

Author: kaimast

ledger/Cargo.toml

@@ -123,6 +123,9 @@ optional = true
 [dependencies.snarkvm-synthesizer]
 workspace = true
 
+[dependencies.snarkvm-utilities]
+workspace = true
+
 [dependencies.aleo-std]
 workspace = true
 features = [ "storage" ]
@@ -188,9 +191,6 @@ features = [ "preserve_order" ]
 [dev-dependencies.snarkvm-circuit]
 workspace = true
 
-[dev-dependencies.snarkvm-utilities]
-workspace = true
-
 [dev-dependencies.snarkvm-synthesizer]
 workspace = true
 features = [ "test" ]

ledger/src/find.rs

@@ -15,6 +15,8 @@
 
 use super::*;
 
+use snarkvm_utilities::LoggableError;
+
 impl<N: Network, C: ConsensusStorage<N>> Ledger<N, C> {
     /// Returns the block height that contains the given `state root`.
     pub fn find_block_height_from_state_root(&self, state_root: N::StateRoot) -> Result<Option<u32>> {
@@ -128,8 +130,8 @@ impl<N: Network, C: ConsensusStorage<N>> Ledger<N, C> {
             match commitment {
                 Ok(Some(commitment)) => Some((commitment, record)),
                 Ok(None) => None,
-                Err(e) => {
-                    warn!("Failed to process 'find_record_ciphertexts({:?})': {e}", filter);
+                Err(err) => {
+                    err.log_warning(format!("Failed to process 'find_record_ciphertexts({filter:?})'"));
                     None
                 }
             }
@@ -146,8 +148,8 @@ impl<N: Network, C: ConsensusStorage<N>> Ledger<N, C> {
         self.find_record_ciphertexts(view_key, filter).map(|iter| {
             iter.flat_map(|(commitment, record)| match record.decrypt(view_key) {
                 Ok(record) => Some((commitment, record)),
-                Err(e) => {
-                    warn!("Failed to decrypt the record: {e}");
+                Err(err) => {
+                    err.log_warning("Failed to decrypt record");
                     None
                 }
             })

ledger/store/Cargo.toml

@@ -19,7 +19,7 @@ edition = "2024"
 [features]
 default = [ "indexmap/rayon" ]
 locktick = [ "dep:locktick", "snarkvm-ledger-puzzle/locktick" ]
-rocks = [ "rocksdb", "smallvec", "tracing" ]
+rocks = [ "rocksdb", "smallvec" ]
 serial = [
   "snarkvm-console/serial",
   "snarkvm-ledger-block/serial",
@@ -109,10 +109,6 @@ workspace = true
 features = [ "write" ]
 optional = true
 
-[dependencies.tracing]
-workspace = true
-optional = true
-
 [dev-dependencies.aleo-std]
 workspace = true
 
@@ -131,3 +127,6 @@ workspace = true
 
 [dev-dependencies.tracing-test]
 version = "0.2.5"
+
+[dev-dependencies.tracing]
+workspace = true

ledger/store/src/helpers/rocksdb/internal/map.rs

@@ -18,13 +18,12 @@
 use super::*;
 use crate::helpers::{Map, MapRead};
 
-use snarkvm_utilities::bytes::unchecked_deserialize;
+use snarkvm_utilities::{LoggableError, bytes::unchecked_deserialize};
 
 use core::{fmt, fmt::Debug, hash::Hash, mem};
 use indexmap::IndexMap;
 use smallvec::SmallVec;
 use std::{borrow::Cow, ops::Deref, path::Path, sync::atomic::Ordering};
-use tracing::error;
 
 #[derive(Clone)]
 pub struct DataMap<K: Serialize + DeserializeOwned, V: Serialize + DeserializeOwned>(
@@ -456,15 +455,10 @@ impl<
 
         // Deserialize the key and value.
         let key = unchecked_deserialize(&key[PREFIX_LEN..])
-            .map_err(|e| {
-                error!("RocksDB Iter deserialize(key) error: {e}");
-            })
-            .ok()?;
-        let value = unchecked_deserialize(value)
-            .map_err(|e| {
-                error!("RocksDB Iter deserialize(value) error: {e}");
-            })
+            .map_err(|err| err.log_error("RocksDB Iter deserialize(key) error"))
             .ok()?;
+        let value =
+            unchecked_deserialize(value).map_err(|err| err.log_error("RocksDB Iter deserialize(value) error")).ok()?;
 
         self.db_iter.next();
 
@@ -494,9 +488,7 @@ impl<'a, K: 'a + Clone + Debug + PartialEq + Eq + Hash + Serialize + Deserialize
 
         // Deserialize the key.
         let key = unchecked_deserialize(&self.db_iter.key()?[PREFIX_LEN..])
-            .map_err(|e| {
-                error!("RocksDB Keys deserialize(key) error: {e}");
-            })
+            .map_err(|err| err.log_error("RocksDB Keys deserialize(key) error"))
             .ok()?;
 
         self.db_iter.next();
@@ -527,9 +519,7 @@ impl<'a, V: 'a + Clone + Serialize + DeserializeOwned> Iterator for Values<'a, V
 
         // Deserialize the value.
         let value = unchecked_deserialize(self.db_iter.value()?)
-            .map_err(|e| {
-                error!("RocksDB Values deserialize(value) error: {e}");
-            })
+            .map_err(|err| err.log_error("RocksDB Values deserialize(value) error"))
             .ok()?;
 
         self.db_iter.next();

ledger/store/src/helpers/rocksdb/internal/nested_map.rs

@@ -18,12 +18,11 @@
 use super::*;
 use crate::helpers::{NestedMap, NestedMapRead};
 use console::prelude::{FromBytes, anyhow, cfg_into_iter};
-use snarkvm_utilities::bytes::unchecked_deserialize;
+use snarkvm_utilities::{LoggableError, bytes::unchecked_deserialize};
 
 use anyhow::Context;
 use core::{fmt, fmt::Debug, hash::Hash, mem};
 use std::{borrow::Cow, sync::atomic::Ordering};
-use tracing::error;
 
 #[cfg(not(feature = "serial"))]
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
@@ -648,28 +647,19 @@ impl<
         let (map_key, value) = self.db_iter.item()?;
 
         // Extract the bytes belonging to the map and the key.
-        let (entry_map, entry_key) = get_map_and_key(map_key)
-            .map_err(|e| {
-                error!("RocksDB NestedIter get_map_and_key error: {e}");
-            })
-            .ok()?;
+        let (entry_map, entry_key) =
+            get_map_and_key(map_key).map_err(|err| err.log_error("RocksDB NestedIter get_map_and_key error")).ok()?;
 
         // Deserialize the map, key, and value.
         let map = unchecked_deserialize(entry_map)
-            .map_err(|e| {
-                error!("RocksDB NestedIter deserialize(map) error: {e}");
-            })
+            .map_err(|err| err.log_error("RocksDB NestedIter deserialize(map) error"))
             .ok()?;
         let key = unchecked_deserialize(entry_key)
-            .map_err(|e| {
-                error!("RocksDB NestedIter deserialize(key) error: {e}");
-            })
+            .map_err(|err| err.log_error("RocksDB NestedIter deserialize(key) error"))
             .ok()?;
         // Deserialize the value.
         let value = unchecked_deserialize(value)
-            .map_err(|e| {
-                error!("RocksDB NestedIter deserialize(value) error: {e}");
-            })
+            .map_err(|err| err.log_error("RocksDB NestedIter deserialize(value) error"))
             .ok()?;
 
         self.db_iter.next();
@@ -715,22 +705,15 @@ impl<
         let map_key = self.db_iter.key()?;
 
         // Extract the bytes belonging to the map and the key.
-        let (entry_map, entry_key) = get_map_and_key(map_key)
-            .map_err(|e| {
-                error!("RocksDB NestedKeys get_map_and_key error: {e}");
-            })
-            .ok()?;
+        let (entry_map, entry_key) =
+            get_map_and_key(map_key).map_err(|err| err.log_error("RocksDB NestedKeys get_map_and_key error")).ok()?;
 
         // Deserialize the map and key.
         let map = unchecked_deserialize(entry_map)
-            .map_err(|e| {
-                error!("RocksDB NestedKeys deserialize(map) error: {e}");
-            })
+            .map_err(|err| err.log_error("RocksDB NestedKeys deserialize(map) error"))
             .ok()?;
         let key = unchecked_deserialize(entry_key)
-            .map_err(|e| {
-                error!("RocksDB NestedKeys deserialize(key) error: {e}");
-            })
+            .map_err(|err| err.log_error("RocksDB NestedKeys deserialize(key) error"))
             .ok()?;
 
         self.db_iter.next();
@@ -763,8 +746,8 @@ impl<'a, V: 'a + Clone + Serialize + DeserializeOwned> Iterator for NestedValues
 
         // Deserialize the value.
         let value = unchecked_deserialize(value)
-            .map_err(|e| {
-                error!("RocksDB NestedValues deserialize(value) error: {e}");
+            .map_err(|err| {
+                err.log_error("RocksDB NestedValues deserialize(value) error");
             })
             .ok()?;
 

utilities/src/errors.rs

@@ -88,7 +88,20 @@ macro_rules! ensure_equals {
     };
 }
 
-/// A trait that allows turning  an Error into a log message.
+/// A trait that allows printing the entire error chain of an Error (it is implemented for [`anyhow::Error`]) along with a custom context message.
+///
+/// This reduces the need for custom error printing code and ensures consistency across log messages.
+///
+/// # Example
+/// The following code will log `user-facing message - low level error` as an error.
+///
+/// ```rust
+/// use anyhow::anyhow;
+/// use snarkvm_utilities::LoggableError;
+///
+/// let my_error = anyhow!("low level problem");
+/// my_error.log_error("user-facing message");
+/// ```
 pub trait LoggableError {
     /// Log the error with the given context and log level `ERROR`.
     fn log_error<S: Send + Sync + Display + 'static>(self, context: S);
@@ -128,7 +141,7 @@ impl<E: Into<anyhow::Error>> LoggableError for E {
 pub trait PrettyUnwrap {
     type Inner;
 
-    /// Behaves like [`std::Result::unwrap`] but will print the entire anyhow chain to stderr.
+    /// Behaves like [`std::result::Result::unwrap`] but will print the entire anyhow chain to stderr.
     fn pretty_unwrap(self) -> Self::Inner;
 }
 

utilities/src/lib.rs

@@ -50,10 +50,12 @@ mod print;
 pub mod rand;
 pub use self::rand::*;
 
+/// Helpers for data (de-)serialization.
 pub mod serialize;
 pub use serialize::*;
 
-mod errors;
+/// Helpers for error handling.
+pub mod errors;
 pub use errors::*;
 
 /// Use old name for backward-compatibility.