chore(cluster): log descriptor version and drain lifecycle details

A persistent descriptor mismatch signals a planner/leaseholder
disagreement rather than the transient race the retry path assumes,
but the expected/actual versions were dropped before reaching the
gateway error. Log them at both the exec receiver and the gateway, and
trace drain install/release so a stuck drain is diagnosable from logs
instead of only from its TTL expiry.

Author: farhan-syah

nodedb/src/control/exec_receiver/executor.rs

@@ -146,6 +146,12 @@ impl LocalPlanExecutor {
                             stored.descriptor_version
                         };
                         if actual != entry.version {
+                            tracing::debug!(
+                                collection = %entry.collection,
+                                expected_version = entry.version,
+                                actual_version = actual,
+                                "exec receiver: descriptor version mismatch"
+                            );
                             return Err(TypedClusterError::DescriptorMismatch {
                                 collection: entry.collection.clone(),
                                 expected_version: entry.version,

nodedb/src/control/gateway/dispatcher.rs

@@ -321,9 +321,26 @@ pub(super) fn map_typed_cluster_error(err: TypedClusterError, vshard_id: u64) ->
             leader_node: leader_node_id.unwrap_or(0),
             leader_addr: leader_addr.unwrap_or_default(),
         },
-        TypedClusterError::DescriptorMismatch { collection, .. } => Error::RetryableSchemaChanged {
-            descriptor: collection,
-        },
+        TypedClusterError::DescriptorMismatch {
+            collection,
+            expected_version,
+            actual_version,
+        } => {
+            // The versions are the whole diagnosis for this error: a mismatch
+            // that keeps repeating means the planner and the leaseholder
+            // disagree persistently, which is a bug rather than the transient
+            // race the retry assumes. Dropping them leaves "retryable schema
+            // change" with nothing to act on.
+            tracing::debug!(
+                %collection,
+                expected_version,
+                actual_version,
+                "gateway: descriptor version mismatch at leaseholder"
+            );
+            Error::RetryableSchemaChanged {
+                descriptor: collection,
+            }
+        }
         TypedClusterError::DeadlineExceeded { .. } => Error::DeadlineExceeded {
             request_id: crate::types::RequestId::new(0),
         },

nodedb/src/control/lease/drain.rs

@@ -68,6 +68,12 @@ impl DescriptorDrainTracker {
     /// Called by the metadata applier on every node when a
     /// `DescriptorDrainStart` raft entry commits.
     pub fn install_start(&self, id: DescriptorId, up_to_version: u64, expires_at: Hlc) {
+        tracing::debug!(
+            ?id,
+            up_to_version,
+            expires_wall_ns = expires_at.wall_ns,
+            "drain: install_start"
+        );
         let mut map = self.active.write().unwrap_or_else(|p| p.into_inner());
         map.insert(
             id,
@@ -83,6 +89,7 @@ impl DescriptorDrainTracker {
     /// raft entries AND on the implicit clear path that runs
     /// after a successful `Put*` apply.
     pub fn install_end(&self, id: &DescriptorId) {
+        tracing::debug!(?id, "drain: install_end");
         let mut map = self.active.write().unwrap_or_else(|p| p.into_inner());
         map.remove(id);
     }