fix(scanner): back off clean idle scans across erasure clusters (#4984)

* fix(scanner): back off clean single-disk cycles

* fix(scanner): extend idle backoff across erasure clusters

---------

Co-authored-by: Henry Guo <marshawcoco@users.noreply.github.com>

crates/ecstore/src/api/mod.rs

@@ -376,7 +376,7 @@ pub mod rio {
 pub mod rpc {
     pub use crate::cluster::rpc::{
         LocalPeerS3Client, PEER_RESTSIGNAL, PEER_RESTSUB_SYS, PeerRestClient, PeerS3Client, SERVICE_SIGNAL_REFRESH_CONFIG,
-        SERVICE_SIGNAL_RELOAD_DYNAMIC, TONIC_RPC_PREFIX, TonicInterceptor, gen_tonic_signature_interceptor,
+        SERVICE_SIGNAL_RELOAD_DYNAMIC, ScannerPeerActivity, TONIC_RPC_PREFIX, TonicInterceptor, gen_tonic_signature_interceptor,
         node_service_time_out_client, node_service_time_out_client_no_auth, verify_rpc_signature,
     };
 }

crates/ecstore/src/cluster/rpc/mod.rs

@@ -34,6 +34,7 @@ pub(crate) use internode_data_transport::TcpHttpInternodeDataTransport;
 pub use internode_data_transport::build_internode_data_transport_from_env;
 pub use peer_rest_client::{
     PEER_RESTSIGNAL, PEER_RESTSUB_SYS, PeerRestClient, SERVICE_SIGNAL_REFRESH_CONFIG, SERVICE_SIGNAL_RELOAD_DYNAMIC,
+    ScannerPeerActivity,
 };
 pub(crate) use peer_s3_client::heal_bucket_local_on_disks;
 pub use peer_s3_client::{LocalPeerS3Client, PeerS3Client, S3PeerSys};

crates/ecstore/src/cluster/rpc/peer_rest_client.rs

@@ -34,9 +34,9 @@ use rustfs_protos::proto_gen::node_service::{
     GetNetInfoRequest, GetOsInfoRequest, GetPartitionsRequest, GetProcInfoRequest, GetSeLinuxInfoRequest, GetSysConfigRequest,
     GetSysErrorsRequest, LoadBucketMetadataRequest, LoadGroupRequest, LoadPolicyMappingRequest, LoadPolicyRequest,
     LoadRebalanceMetaRequest, LoadServiceAccountRequest, LoadTransitionTierConfigRequest, LoadUserRequest,
-    LocalStorageInfoRequest, Mss, ReloadPoolMetaRequest, ReloadSiteReplicationConfigRequest, ServerInfoRequest,
-    SignalServiceRequest, StartDecommissionRequest, StartProfilingRequest, StopRebalanceRequest,
-    node_service_client::NodeServiceClient,
+    LocalStorageInfoRequest, Mss, ReloadPoolMetaRequest, ReloadSiteReplicationConfigRequest, ScannerActivityRequest,
+    ScannerActivityResponse, ServerInfoRequest, SignalServiceRequest, StartDecommissionRequest, StartProfilingRequest,
+    StopRebalanceRequest, node_service_client::NodeServiceClient,
 };
 use rustfs_utils::XHost;
 use serde::{Deserialize, Serialize as _};
@@ -62,6 +62,31 @@ pub const SERVICE_SIGNAL_REFRESH_CONFIG: u64 = 1;
 pub const SERVICE_SIGNAL_RELOAD_DYNAMIC: u64 = 2;
 const PEER_REST_RECOVERY_MAX_ATTEMPTS: u32 = 60;
 const PEER_REST_RECOVERY_MAX_BACKOFF: Duration = Duration::from_secs(30);
+const SCANNER_ACTIVITY_MAX_MESSAGE_SIZE: usize = 1024;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ScannerPeerActivity {
+    pub instance_id: String,
+    pub namespace_generation: u64,
+    pub maintenance_generation: u64,
+}
+
+fn decode_scanner_activity(response: ScannerActivityResponse) -> Result<ScannerPeerActivity> {
+    let instance_id = response.instance_id;
+    if instance_id.len() != 32
+        || !instance_id
+            .as_bytes()
+            .iter()
+            .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(byte))
+    {
+        return Err(Error::other("peer returned an invalid scanner activity instance ID"));
+    }
+    Ok(ScannerPeerActivity {
+        instance_id,
+        namespace_generation: response.namespace_generation,
+        maintenance_generation: response.maintenance_generation,
+    })
+}
 
 #[derive(Clone, Debug)]
 pub struct PeerLiveEventsBatch {
@@ -639,12 +664,13 @@ impl PeerRestClient {
         Err(Error::NotImplemented)
     }
 
-    pub async fn load_bucket_metadata(&self, bucket: &str) -> Result<()> {
+    pub async fn load_bucket_metadata(&self, bucket: &str, scanner_maintenance_change: bool) -> Result<()> {
         self.finalize_result(
             async {
                 let mut client = self.get_client().await?;
                 let request = Request::new(LoadBucketMetadataRequest {
                     bucket: bucket.to_string(),
+                    scanner_maintenance_change,
                 });
 
                 let response = client.load_bucket_metadata(request).await?.into_inner();
@@ -908,6 +934,25 @@ impl PeerRestClient {
         .await
     }
 
+    pub async fn scanner_activity(&self) -> Result<ScannerPeerActivity> {
+        self.finalize_result(
+            async {
+                let mut client = self
+                    .get_client()
+                    .await?
+                    .max_decoding_message_size(SCANNER_ACTIVITY_MAX_MESSAGE_SIZE)
+                    .max_encoding_message_size(SCANNER_ACTIVITY_MAX_MESSAGE_SIZE);
+                let response = client
+                    .scanner_activity(Request::new(ScannerActivityRequest {}))
+                    .await?
+                    .into_inner();
+                decode_scanner_activity(response)
+            }
+            .await,
+        )
+        .await
+    }
+
     pub async fn get_metacache_listing(&self) -> Result<()> {
         warn!("get_metacache_listing is not implemented in PeerRestClient");
         Err(Error::NotImplemented)
@@ -1157,6 +1202,48 @@ mod tests {
         )
     }
 
+    #[test]
+    fn scanner_activity_requires_restart_safe_peer_identity() {
+        let missing_instance = ScannerActivityResponse {
+            instance_id: String::new(),
+            namespace_generation: 7,
+            maintenance_generation: 3,
+        };
+        assert!(
+            decode_scanner_activity(missing_instance)
+                .expect_err("an empty instance ID is not restart safe")
+                .to_string()
+                .contains("instance ID")
+        );
+
+        let malformed_instance = ScannerActivityResponse {
+            instance_id: "ABCDEF0123456789ABCDEF0123456789".to_string(),
+            namespace_generation: 7,
+            maintenance_generation: 3,
+        };
+        assert!(
+            decode_scanner_activity(malformed_instance)
+                .expect_err("activity instance IDs must use the canonical lowercase hex form")
+                .to_string()
+                .contains("instance ID")
+        );
+
+        let activity = decode_scanner_activity(ScannerActivityResponse {
+            instance_id: "0123456789abcdef0123456789abcdef".to_string(),
+            namespace_generation: 7,
+            maintenance_generation: 3,
+        })
+        .expect("complete activity responses should be accepted");
+        assert_eq!(
+            activity,
+            ScannerPeerActivity {
+                instance_id: "0123456789abcdef0123456789abcdef".to_string(),
+                namespace_generation: 7,
+                maintenance_generation: 3,
+            }
+        );
+    }
+
     #[test]
     fn peer_rest_client_marks_network_like_errors() {
         assert!(PeerRestClient::is_network_like_error(&Error::other("transport error")));

crates/ecstore/src/services/notification_sys.rs

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::cluster::rpc::PeerRestClient;
+use crate::cluster::rpc::{PeerRestClient, ScannerPeerActivity};
 use crate::diagnostics::admin_server_info::get_commit_id;
 use crate::disk::DiskAPI;
 use crate::error::{Error, Result};
@@ -41,6 +41,7 @@ const CONSECUTIVE_FAILURE_THRESHOLD: u32 = 3;
 const LOG_COMPONENT_ECSTORE: &str = "ecstore";
 const LOG_SUBSYSTEM_NOTIFICATION: &str = "notification";
 const EVENT_NOTIFICATION_PEER_PROPAGATION: &str = "notification_peer_propagation";
+const SCANNER_ACTIVITY_PROBE_TIMEOUT: Duration = Duration::from_secs(5);
 
 /// Cached result from the last successful admin call to a peer.
 struct PeerAdminCache {
@@ -91,7 +92,6 @@ pub fn get_global_notification_sys() -> Option<Arc<NotificationSys>> {
 
 pub struct NotificationSys {
     pub peer_clients: Vec<Option<PeerRestClient>>,
-    #[allow(dead_code)]
     pub all_peer_clients: Vec<Option<PeerRestClient>>,
     peer_admin_caches: Vec<Mutex<PeerAdminCache>>,
 }
@@ -756,6 +756,14 @@ impl NotificationSys {
     }
 
     pub async fn load_bucket_metadata(&self, bucket: &str) -> Result<()> {
+        self.load_bucket_metadata_with_scanner_maintenance(bucket, false).await
+    }
+
+    pub async fn load_bucket_metadata_for_scanner_maintenance(&self, bucket: &str) -> Result<()> {
+        self.load_bucket_metadata_with_scanner_maintenance(bucket, true).await
+    }
+
+    async fn load_bucket_metadata_with_scanner_maintenance(&self, bucket: &str, scanner_maintenance_change: bool) -> Result<()> {
         let operation = format!("load_bucket_metadata({bucket})");
         let mut failures = Vec::new();
         let mut futures = Vec::with_capacity(self.peer_clients.len());
@@ -763,7 +771,12 @@ impl NotificationSys {
             if let Some(client) = client {
                 let host = client.host.to_string();
                 let b = bucket.to_string();
-                futures.push(async move { client.load_bucket_metadata(&b).await.map_err(|err| (host, err)) });
+                futures.push(async move {
+                    client
+                        .load_bucket_metadata(&b, scanner_maintenance_change)
+                        .await
+                        .map_err(|err| (host, err))
+                });
             } else {
                 failures.push(format!("peer[{idx}] {operation} failed: peer is not reachable"));
             }
@@ -976,6 +989,36 @@ impl NotificationSys {
         join_all(futures).await
     }
 
+    pub async fn scanner_activity_snapshots(&self) -> Result<Vec<(String, ScannerPeerActivity)>> {
+        if self.peer_clients.is_empty() {
+            return Err(Error::other("scanner activity probe has no remote peers"));
+        }
+        if self.all_peer_clients.len() != self.peer_clients.len() + 1 {
+            return Err(Error::other(format!(
+                "scanner activity peer topology is incomplete: {} remote peers for {} cluster members",
+                self.peer_clients.len(),
+                self.all_peer_clients.len()
+            )));
+        }
+
+        let mut futures = Vec::with_capacity(self.peer_clients.len());
+        for (idx, client) in self.peer_clients.iter().cloned().enumerate() {
+            futures.push(async move {
+                let client = client.ok_or_else(|| Error::other(format!("scanner activity peer[{idx}] is unreachable")))?;
+                let host = client.grid_host.clone();
+                scanner_activity_with_timeout(SCANNER_ACTIVITY_PROBE_TIMEOUT, &host, client.scanner_activity())
+                    .await
+                    .map(|activity| (host, activity))
+            });
+        }
+
+        let mut generations = Vec::with_capacity(futures.len());
+        for result in join_all(futures).await {
+            generations.push(result?);
+        }
+        Ok(generations)
+    }
+
     pub async fn reload_site_replication_config(&self) -> Vec<NotificationPeerErr> {
         let mut futures = Vec::with_capacity(self.peer_clients.len());
         for client in self.peer_clients.iter() {
@@ -1029,6 +1072,15 @@ impl NotificationSys {
     }
 }
 
+async fn scanner_activity_with_timeout<F>(timeout_duration: Duration, host: &str, activity: F) -> Result<ScannerPeerActivity>
+where
+    F: Future<Output = Result<ScannerPeerActivity>>,
+{
+    timeout(timeout_duration, activity)
+        .await
+        .map_err(|_| Error::other(format!("scanner activity peer {host} timed out after {timeout_duration:?}")))?
+}
+
 async fn call_peer_with_timeout<F, Fut>(
     timeout_dur: Duration,
     host_label: &str,
@@ -1568,6 +1620,72 @@ mod tests {
         assert!(msg.contains("peer[0]"));
     }
 
+    #[tokio::test]
+    async fn scanner_activity_probe_reports_unreachable_peers() {
+        let sys = NotificationSys {
+            peer_clients: vec![None],
+            all_peer_clients: vec![None, None],
+            peer_admin_caches: vec![Mutex::new(PeerAdminCache::new())],
+        };
+
+        let err = sys
+            .scanner_activity_snapshots()
+            .await
+            .expect_err("unreachable peers must disable scanner idle backoff");
+
+        assert!(err.to_string().contains("scanner activity peer[0] is unreachable"));
+    }
+
+    #[tokio::test]
+    async fn scanner_activity_probe_rejects_an_empty_peer_set() {
+        let sys = NotificationSys {
+            peer_clients: Vec::new(),
+            all_peer_clients: Vec::new(),
+            peer_admin_caches: Vec::new(),
+        };
+
+        let err = sys
+            .scanner_activity_snapshots()
+            .await
+            .expect_err("a missing peer set must disable scanner idle backoff");
+
+        assert!(err.to_string().contains("no remote peers"));
+    }
+
+    #[tokio::test]
+    async fn scanner_activity_probe_rejects_an_incomplete_peer_topology() {
+        let client = PeerRestClient::new(
+            "127.0.0.1:9000".to_string().try_into().expect("peer host should parse"),
+            "http://127.0.0.1:9000".to_string(),
+        );
+        let sys = NotificationSys {
+            peer_clients: vec![Some(client)],
+            all_peer_clients: vec![None],
+            peer_admin_caches: vec![Mutex::new(PeerAdminCache::new())],
+        };
+
+        let err = sys
+            .scanner_activity_snapshots()
+            .await
+            .expect_err("an incomplete peer topology must disable scanner idle backoff");
+
+        assert!(err.to_string().contains("peer topology is incomplete"));
+    }
+
+    #[tokio::test]
+    async fn scanner_activity_probe_times_out() {
+        let err = scanner_activity_with_timeout(
+            Duration::from_millis(5),
+            "peer-1",
+            std::future::pending::<Result<ScannerPeerActivity>>(),
+        )
+        .await
+        .expect_err("a stalled peer must not block scanner scheduling");
+
+        assert!(err.to_string().contains("timed out"));
+        assert!(err.to_string().contains("peer-1"));
+    }
+
     #[tokio::test]
     async fn load_bucket_metadata_reports_unreachable_peers() {
         let sys = NotificationSys {

crates/ecstore/src/store/bucket.rs

@@ -392,16 +392,28 @@ mod tests {
     }
 
     async fn create_bucket_with_object(ecstore: &Arc<ECStore>, bucket: &str, object: &str) {
+        let generation_before_make = ecstore.scanner_namespace_mutation_generation();
         ecstore
             .make_bucket(bucket, &MakeBucketOptions::default())
             .await
             .expect("bucket should be created");
+        assert_eq!(
+            ecstore.scanner_namespace_mutation_generation(),
+            generation_before_make.saturating_add(1),
+            "successful bucket creation should advance scanner namespace activity"
+        );
 
+        let generation_before_put = ecstore.scanner_namespace_mutation_generation();
         let mut reader = PutObjReader::from_vec(b"delete bucket semantics".to_vec());
         ecstore
             .put_object(bucket, object, &mut reader, &ObjectOptions::default())
             .await
             .expect("object should be written");
+        assert_eq!(
+            ecstore.scanner_namespace_mutation_generation(),
+            generation_before_put.saturating_add(1),
+            "successful object creation should advance scanner namespace activity"
+        );
         ecstore
             .get_object_info(bucket, object, &ObjectOptions::default())
             .await
@@ -499,6 +511,7 @@ mod tests {
         create_bucket_with_object(&ecstore, &bucket, object).await;
         assert!(metadata_sys::get(&bucket).await.is_ok());
 
+        let generation_before_delete = ecstore.scanner_namespace_mutation_generation();
         ecstore
             .delete_bucket(
                 &bucket,
@@ -509,6 +522,11 @@ mod tests {
             )
             .await
             .expect("MarkDelete should not reject non-empty bucket data");
+        assert_eq!(
+            ecstore.scanner_namespace_mutation_generation(),
+            generation_before_delete.saturating_add(1),
+            "successful bucket deletion should advance scanner namespace activity"
+        );
 
         assert!(
             any_disk_has_object_metadata(&disk_paths, &bucket).await,
@@ -536,6 +554,7 @@ mod tests {
         write_bucket_metadata_marker(&disk_paths, &metadata_prefix).await;
         assert!(any_disk_path_exists(&disk_paths, &metadata_prefix).await);
 
+        let generation_before_delete = ecstore.scanner_namespace_mutation_generation();
         ecstore
             .delete_bucket(
                 &bucket,
@@ -547,6 +566,11 @@ mod tests {
             )
             .await
             .expect("Purge should force-delete bucket data");
+        assert_eq!(
+            ecstore.scanner_namespace_mutation_generation(),
+            generation_before_delete.saturating_add(1),
+            "successful bucket purge should advance scanner namespace activity"
+        );
 
         assert!(!any_disk_path_exists(&disk_paths, &bucket).await, "Purge should remove the bucket volume");
         assert!(
@@ -568,12 +592,18 @@ mod tests {
 
         create_bucket_with_object(&ecstore, &bucket, object).await;
 
+        let generation_before_delete = ecstore.scanner_namespace_mutation_generation();
         let err = ecstore
             .delete_bucket(&bucket, &DeleteBucketOptions::default())
             .await
             .expect_err("default S3 DeleteBucket should reject non-empty buckets");
 
         assert!(matches!(err, StorageError::BucketNotEmpty(name) if name == bucket));
+        assert_eq!(
+            ecstore.scanner_namespace_mutation_generation(),
+            generation_before_delete,
+            "failed bucket deletion must not advance scanner namespace activity"
+        );
         assert!(
             any_disk_has_object_metadata(&disk_paths, &bucket).await,
             "failed default S3 DeleteBucket must keep object data"

crates/ecstore/src/store/list_objects.rs

@@ -541,6 +541,7 @@ impl PersistentListMetadataObject {
 static PERSISTENT_KEY_ONLY_INDEX_CACHE: OnceCell<RwLock<Option<PersistentKeyOnlyIndexCache>>> = OnceCell::const_new();
 static LIST_OBJECTS_NAMESPACE_JOURNAL_LOCK: OnceCell<RwLock<()>> = OnceCell::const_new();
 static LIST_OBJECTS_MUTATION_SEQUENCE: AtomicU64 = AtomicU64::new(0);
+static SCANNER_NAMESPACE_MUTATION_GENERATION: AtomicU64 = AtomicU64::new(0);
 static LIST_OBJECTS_BUCKET_MUTATION_SEQUENCE: OnceCell<RwLock<HashMap<String, u64>>> = OnceCell::const_new();
 static LIST_OBJECTS_NAMESPACE_JOURNAL_DEGRADED_BUCKETS: OnceCell<RwLock<HashSet<String>>> = OnceCell::const_new();
 static LIST_OBJECTS_NAMESPACE_JOURNAL_CHAOS_CONFIG: OnceCell<Option<NamespaceMutationJournalChaosConfig>> = OnceCell::const_new();
@@ -607,6 +608,19 @@ async fn advance_list_objects_mutation_sequence(bucket: &str, sequence: u64) ->
     sequence
 }
 
+pub(super) fn scanner_namespace_mutation_generation() -> u64 {
+    SCANNER_NAMESPACE_MUTATION_GENERATION.load(Ordering::Acquire)
+}
+
+pub(super) fn observe_scanner_namespace_mutations(bucket: &str, delta: u64) {
+    if bucket == RUSTFS_META_BUCKET {
+        return;
+    }
+
+    let _ = SCANNER_NAMESPACE_MUTATION_GENERATION
+        .fetch_update(Ordering::AcqRel, Ordering::Acquire, |current| Some(current.saturating_add(delta)));
+}
+
 pub(super) async fn observe_list_objects_mutation(store: &ECStore, bucket: &str) -> u64 {
     observe_list_objects_mutations(store, bucket, 1).await.unwrap_or_default()
 }
@@ -621,6 +635,7 @@ async fn observe_list_objects_mutations_with_store(store: Option<&ECStore>, buck
     }
 
     let delta = u64::try_from(count).unwrap_or(u64::MAX);
+    observe_scanner_namespace_mutations(bucket, delta);
     let next = LIST_OBJECTS_MUTATION_SEQUENCE
         .fetch_add(delta, Ordering::AcqRel)
         .saturating_add(delta);
@@ -641,6 +656,7 @@ async fn current_list_objects_mutation_sequence(bucket: &str) -> u64 {
 #[cfg(test)]
 async fn reset_list_objects_mutation_sequences_for_test() {
     LIST_OBJECTS_MUTATION_SEQUENCE.store(0, Ordering::Release);
+    SCANNER_NAMESPACE_MUTATION_GENERATION.store(0, Ordering::Release);
     let sequences = list_objects_bucket_mutation_sequence().await;
     sequences.write().await.clear();
     let degraded = list_objects_namespace_journal_degraded_buckets().await;
@@ -6646,11 +6662,11 @@ mod test {
         ListingSupplement, ListingSupplementOptions, MAX_OBJECT_LIST, NamespaceMutationJournalBackend,
         NamespaceMutationJournalSnapshot, NamespaceMutationJournalStatus, PERSISTENT_KEY_ONLY_INDEX_BUCKET_HEADER,
         PERSISTENT_KEY_ONLY_INDEX_CHECKPOINT_HEADER, PERSISTENT_KEY_ONLY_INDEX_GENERATION_HEADER,
-        PERSISTENT_KEY_ONLY_INDEX_HEADER, PersistentKeyOnlyIndex, PersistentListMetadataObject, VerifiedIndexCandidateStats,
-        VersionMarker, current_list_objects_mutation_sequence, encode_persistent_list_metadata_object,
-        enforce_latest_listing_write_quorum, expand_ask_disks_for_object_quorum, fallback_entries_for_object, gather_results,
-        latest_listing_allow_agreed_objects, latest_listing_object_quorum, latest_listing_raw_min_disks,
-        latest_listing_required_object_quorum, list_marker_key, list_metadata_resolution_params,
+        PERSISTENT_KEY_ONLY_INDEX_HEADER, PersistentKeyOnlyIndex, PersistentListMetadataObject, RUSTFS_META_BUCKET,
+        VerifiedIndexCandidateStats, VersionMarker, current_list_objects_mutation_sequence,
+        encode_persistent_list_metadata_object, enforce_latest_listing_write_quorum, expand_ask_disks_for_object_quorum,
+        fallback_entries_for_object, gather_results, latest_listing_allow_agreed_objects, latest_listing_object_quorum,
+        latest_listing_raw_min_disks, latest_listing_required_object_quorum, list_marker_key, list_metadata_resolution_params,
         list_objects_from_metadata_snapshot_candidates, list_objects_from_verified_index_candidates,
         list_objects_from_verified_index_candidates_with_optional_stats, list_objects_from_verified_index_candidates_with_stats,
         list_objects_index_mode_from_env, list_objects_index_provider_from_env, list_objects_index_provider_state_from_env,
@@ -6664,8 +6680,9 @@ mod test {
         parse_version_marker, persist_observed_list_objects_mutation, persistent_key_only_index_has_complete_metadata_snapshot,
         persistent_key_only_index_health, persistent_key_only_index_matches_provider, record_list_objects_index_opt_in_fallback,
         reset_list_objects_mutation_sequences_for_test, resolve_agreed_listing_entry, resolve_listing_entries,
-        select_list_index_provider_source_mode, select_list_index_source_mode, send_or_cancel, version_marker_for_entries,
-        walk_result_from_set_errors, write_namespace_mutation_journal_state, write_persistent_key_only_index,
+        scanner_namespace_mutation_generation, select_list_index_provider_source_mode, select_list_index_source_mode,
+        send_or_cancel, version_marker_for_entries, walk_result_from_set_errors, write_namespace_mutation_journal_state,
+        write_persistent_key_only_index,
     };
     use crate::cache_value::metacache_set::{FallbackClaimTracker, TestReaderBehavior, list_path_raw};
     use crate::disk::{DiskAPI, DiskOption, endpoint::Endpoint, error::DiskError, new_disk};
@@ -8362,6 +8379,19 @@ mod test {
         assert_eq!(current_list_objects_mutation_sequence("bucket-b").await, 0);
     }
 
+    #[tokio::test]
+    #[serial_test::serial]
+    async fn scanner_namespace_generation_tracks_only_user_namespace_mutations() {
+        reset_list_objects_mutation_sequences_for_test().await;
+
+        assert_eq!(scanner_namespace_mutation_generation(), 0);
+        assert_eq!(observe_list_objects_mutations_with_store(None, RUSTFS_META_BUCKET, 3).await, Some(3));
+        assert_eq!(scanner_namespace_mutation_generation(), 0);
+
+        assert_eq!(observe_list_objects_mutations_with_store(None, "photos", 2).await, Some(5));
+        assert_eq!(scanner_namespace_mutation_generation(), 2);
+    }
+
     #[test]
     fn list_objects_index_provider_state_uses_lifecycle_active_generation() {
         let provider = ListObjectsIndexProviderState::from_kind(ListObjectsIndexProviderKind::WalkerKeyOnly);

crates/ecstore/src/store/mod.rs

@@ -318,6 +318,10 @@ impl ECStore {
     pub async fn setup_is_erasure_sd(&self) -> bool {
         self.ctx.is_erasure_sd().await
     }
+
+    pub fn scanner_namespace_mutation_generation(&self) -> u64 {
+        list_objects::scanner_namespace_mutation_generation()
+    }
 }
 
 // impl Clone for ECStore {
@@ -436,7 +440,11 @@ impl BucketOperations for ECStore {
 
     #[instrument(skip(self))]
     async fn make_bucket(&self, bucket: &str, opts: &MakeBucketOptions) -> Result<()> {
-        self.handle_make_bucket(bucket, opts).await
+        let result = self.handle_make_bucket(bucket, opts).await;
+        if result.is_ok() {
+            list_objects::observe_scanner_namespace_mutations(bucket, 1);
+        }
+        result
     }
 
     #[instrument(skip(self))]
@@ -449,7 +457,11 @@ impl BucketOperations for ECStore {
     }
     #[instrument(skip(self))]
     async fn delete_bucket(&self, bucket: &str, opts: &DeleteBucketOptions) -> Result<()> {
-        self.handle_delete_bucket(bucket, opts).await
+        let result = self.handle_delete_bucket(bucket, opts).await;
+        if result.is_ok() {
+            list_objects::observe_scanner_namespace_mutations(bucket, 1);
+        }
+        result
     }
 }