[Storage] Add qmdb::any tracing (#3737)

Co-authored-by: Roberto Bayardo <roberto@commonware.xyz>

Author: danlaine

storage/src/qmdb/any/batch.rs

@@ -981,6 +981,16 @@ where
     Operation<F, update::Unordered<K, V>>: Codec,
 {
     /// Resolve mutations into operations, merkleize, and return an `Arc<MerkleizedBatch>`.
+    #[allow(clippy::type_complexity)]
+    #[tracing::instrument(
+        name = "qmdb::any::batch::merkleize",
+        level = "info",
+        skip_all,
+        fields(
+            variant = "unordered",
+            mutations = self.mutations.len() as u64,
+        ),
+    )]
     pub async fn merkleize<E, C, I, const N: usize>(
         self,
         db: &Db<F, E, C, I, H, update::Unordered<K, V>, N, S>,
@@ -1143,6 +1153,16 @@ where
     Operation<F, update::Ordered<K, V>>: Codec,
 {
     /// Resolve mutations into operations, merkleize, and return an `Arc<MerkleizedBatch>`.
+    #[allow(clippy::type_complexity)]
+    #[tracing::instrument(
+        name = "qmdb::any::batch::merkleize",
+        level = "info",
+        skip_all,
+        fields(
+            variant = "ordered",
+            mutations = self.mutations.len() as u64,
+        ),
+    )]
     pub async fn merkleize<E, C, I, const N: usize>(
         self,
         db: &Db<F, E, C, I, H, update::Ordered<K, V>, N, S>,
@@ -1508,6 +1528,17 @@ where
     /// All uncommitted ancestors in the chain must be kept alive until the child (or any
     /// descendant) is merkleized. Dropping an uncommitted ancestor causes data
     /// loss detected at `apply_batch` time.
+    #[tracing::instrument(
+        name = "qmdb::any::batch::new",
+        level = "debug",
+        skip_all,
+        fields(
+            source = "batch",
+            base_size = self.bounds.base_size,
+            total_size = self.bounds.total_size,
+            ancestor_batches = self.ancestor_diffs.len() as u64,
+        ),
+    )]
     pub fn new_batch<H>(self: &Arc<Self>) -> UnmerkleizedBatch<F, H, U, S>
     where
         H: Hasher<Digest = D>,
@@ -1616,6 +1647,17 @@ where
     Operation<F, U>: Codec,
 {
     /// Create a new speculative batch of operations with this database as its parent.
+    #[tracing::instrument(
+        name = "qmdb::any::batch::new",
+        level = "debug",
+        skip_all,
+        fields(
+            source = "db",
+            base_size = *self.last_commit_loc + 1,
+            inactivity_floor = *self.inactivity_floor_loc,
+            active_keys = self.active_keys as u64,
+        ),
+    )]
     pub fn new_batch(&self) -> UnmerkleizedBatch<F, H, U, S> {
         // The DB is always committed, so journal size = last_commit_loc + 1.
         let journal_size = *self.last_commit_loc + 1;
@@ -1651,6 +1693,17 @@ where
     /// This publishes the batch to the in-memory database state and appends it to the
     /// journal, but does not durably persist it. Call [`Db::commit`] or [`Db::sync`] to
     /// guarantee durability.
+    #[tracing::instrument(
+        name = "qmdb::any::Db::apply_batch",
+        level = "info",
+        skip_all,
+        fields(
+            batch_total_size = batch.bounds.total_size,
+            batch_base_size = batch.bounds.base_size,
+            db_size = *self.last_commit_loc + 1,
+            ancestor_batches = batch.ancestor_diffs.len() as u64,
+        ),
+    )]
     pub async fn apply_batch(
         &mut self,
         batch: Arc<MerkleizedBatch<F, H::Digest, U, S>>,
@@ -1742,6 +1795,16 @@ where
     /// Create an initial [`MerkleizedBatch`] from the committed DB state.
     ///
     /// This is the starting point for building owned batch chains.
+    #[tracing::instrument(
+        name = "qmdb::any::Db::to_batch",
+        level = "info",
+        skip_all,
+        fields(
+            db_size = *self.last_commit_loc + 1,
+            inactivity_floor = *self.inactivity_floor_loc,
+            active_keys = self.active_keys as u64,
+        ),
+    )]
     pub fn to_batch(&self) -> Arc<MerkleizedBatch<F, H::Digest, U, S>> {
         // The DB is always committed, so journal size = last_commit_loc + 1.
         let journal_size = *self.last_commit_loc + 1;

storage/src/qmdb/any/db.rs

@@ -356,6 +356,15 @@ where
 
     /// Prune historical operations prior to `prune_loc`. This does not affect the db's root or
     /// snapshot.
+    #[tracing::instrument(
+        name = "qmdb::any::Db::prune",
+        level = "info",
+        skip_all,
+        fields(
+            requested_loc = *prune_loc,
+            inactivity_floor = *self.inactivity_floor_loc,
+        ),
+    )]
     pub async fn prune(&mut self, prune_loc: Location<F>) -> Result<(), crate::qmdb::Error<F>> {
         let _timer = self.metrics.operations.prune_timer();
         self.metrics.operations.prune_calls.inc();
@@ -378,6 +387,17 @@ where
     /// Returns [`crate::qmdb::Error::HistoricalFloorPruned`] if `historical_size - 1` is retained
     /// but is not a commit op, either because the caller passed a non-commit-boundary size or
     /// because pruning removed the commit that would have governed it.
+    #[allow(clippy::type_complexity)]
+    #[tracing::instrument(
+        name = "qmdb::any::Db::historical_proof",
+        level = "info",
+        skip_all,
+        fields(
+            historical_size = *historical_size,
+            start_loc = *start_loc,
+            max_ops = max_ops.get(),
+        ),
+    )]
     pub async fn historical_proof(
         &self,
         historical_size: Location<F>,
@@ -432,6 +452,15 @@ where
     ///
     /// A successful rewind is not restart-stable until a subsequent [`Db::commit`] or
     /// [`Db::sync`].
+    #[tracing::instrument(
+        name = "qmdb::any::Db::rewind",
+        level = "info",
+        skip_all,
+        fields(
+            target_size = *size,
+            prev_size = *self.last_commit_loc + 1,
+        ),
+    )]
     pub async fn rewind(&mut self, size: Location<F>) -> Result<(), Error<F>> {
         let rewind_size = *size;
         let current_size = *self.last_commit_loc + 1;
@@ -707,6 +736,16 @@ where
     }
 
     /// Sync all database state to disk.
+    #[tracing::instrument(
+        name = "qmdb::any::Db::sync",
+        level = "info",
+        skip_all,
+        fields(
+            db_size = *self.last_commit_loc + 1,
+            inactivity_floor = *self.inactivity_floor_loc,
+            active_keys = self.active_keys as u64,
+        ),
+    )]
     pub async fn sync(&self) -> Result<(), crate::qmdb::Error<F>> {
         let _timer = self.metrics.operations.sync_timer();
         self.metrics.operations.sync_calls.inc();
@@ -716,6 +755,16 @@ where
 
     /// Durably commit the journal state published by prior [`Db::apply_batch`]
     /// calls.
+    #[tracing::instrument(
+        name = "qmdb::any::Db::commit",
+        level = "info",
+        skip_all,
+        fields(
+            db_size = *self.last_commit_loc + 1,
+            inactivity_floor = *self.inactivity_floor_loc,
+            active_keys = self.active_keys as u64,
+        ),
+    )]
     pub async fn commit(&self) -> Result<(), crate::qmdb::Error<F>> {
         let _timer = self.metrics.operations.commit_timer();
         self.metrics.operations.commit_calls.inc();